Stability without rigidity and plasticity without chaos.
select
[d].[name] [Database Name]
,databasepropertyex( [d].[name], 'COLLATION' ) [Database Collation]
,serverproperty( 'COLLATION' ) [Server Collation]
from [sys].[databases] [d]
where ( databasepropertyex( [d].[name], 'COLLATION' )) != serverproperty( 'COLLATION' );
select
concat( quotename( [s].[name] ), N'.', quotename( [t].[name] ), N'.', quotename( [c].[name] ) ) [Column_Name]
,[c].[collation_name] [Collation]
from [sys].[schemas] [s]
join [sys].[tables] [t] on [t].[schema_id] = [s].[schema_id]
join [sys].[columns] [c] on [c].[object_id] = [t].[object_id]
where [c].[collation_name] is not null
order by [Column_Name];
Borders don’t make you any safer.
Protiguous, 2021
Borders only keep out potential friends.
public static IEnumerable<T> Concat<T>( this IEnumerable<T> left, IEnumerable<T> right ) {
foreach ( var a in left ) {
yield return a;
}
foreach ( var b in right ) {
yield return b;
}
}
public static T[] Concat<T>( this T[] array1, T[] array2 ) {
var result = new T[ array1.LongLength + array2.LongLength ];
array1.CopyTo( result, 0 );
array2.CopyTo( result, array1.LongLength );
return result;
}
/// <summary>
/// Create only 1 instance of <see cref="T" /> per thread. (Only unique when using this method!)
/// </summary>
/// <typeparam name="T"></typeparam>
public static class Cache<T> where T : notnull, new() {
private static ThreadLocal<T> LocalCache { get; } = new(() => new T(), false);
public static T? Instance { get; } = LocalCache.Value;
}
public static class SwapExt
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void Swap<T>(ref T? left, ref T? right) => (left, right) = (right, left);
[Pure]
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static (T? right, T? left) Swap<T>(this T? left, T? right) => (right, left);
[Pure]
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static (T? right, T? left) Swap<T>((T? left, T? right) tuple) => (tuple.right, tuple.left);
}
C# has a nice ?? operator that can be chained.
In a statement, it will return the first non-null value or null if none are found to not be null.
For example, if you had the code:
string? value1 = null;
string? value2 = nameof(value2);
string? result = value1 != null ? value1 : value2;
The last line could be simplified down to:
string result = value1 ?? value2;
As far as I know, there is no limit on how many ?? can be chained!
Only Important People pay taxes.
Protiguous, 2021
I had a dream… A dream last night.
I saw the world in a different light.
A place to live without despair.
Where men can breathe a clearer air.A joy like this, I’ve never known.
It filled my heart and filled my soul.And the dream of peace lives on..
Protiguous, 2021
And the dream of peace lives on!
Note: This song may be from my childhood, but I have been unable to find it again.
