static void Main(string[] args) { //Builder Pattern karmaşık sınıfların nesne üretim sürecini Client'tan gizleyen bir pattern’dir. GenericExtensions.WriteToConsole("Merhaba Dünya!"); GenericExtensions.WriteToConsole("Builder Pattern Örneği\n"); // Client ilk olarak Director nesnesi alan // ve üretime geçen Builder nesnesini oluşturur. // Oluşturulan nesneler Builder nesnesinden üretilmiş olur. var director = new Director(); var builder = new ProductBuilder(); director.Builder = builder; GenericExtensions.WriteToConsole("Temel ürün üretimi:"); director.buildMinimalViableProduct(); GenericExtensions.WriteToConsole(builder.GetProduct().ListParts()); GenericExtensions.WriteToConsole("Full ürün üretimi:"); director.buildFullFeaturedProduct(); GenericExtensions.WriteToConsole(builder.GetProduct().ListParts()); // Builder Pattern Director olmadan da kullanılabilir. GenericExtensions.WriteToConsole("Özel ürün üretimi:"); builder.BuildPartA(); builder.BuildPartC(); GenericExtensions.WriteToConsole(builder.GetProduct().ListParts()); "\nDevam etmek için enter e basınız".WriteToConsole(); System.Console.ReadLine(); }
public void ProcessChange(TextContentChangedEventArgs e) { foreach (var change in e.Changes) { var lineNumber = e.Before.GetLineNumberFromPosition(change.OldPosition); if (lineNumber < 0 || lineNumber >= _lineMap.Count) { GenericExtensions.Debug(); return; } _lineMap[lineNumber].IsModified = true; if (change.LineCountDelta >= 0) { if (lineNumber + 1 > _lineMap.Count) { GenericExtensions.Debug(); return; } _lineMap.InsertRange(lineNumber + 1, Enumerable.Range(0, change.LineCountDelta).Select(p => new LineStatus(-1))); } else { if (lineNumber + 1 > _lineMap.Count || lineNumber + 1 - change.LineCountDelta > _lineMap.Count) { GenericExtensions.Debug(); return; } _lineMap.RemoveRange(lineNumber + 1, -change.LineCountDelta); } } }
/// <summary> /// Returns a copy of the given <see cref="IEnumerable{T}"/> that is shuffled using the Fisher-Yates algorithm. /// </summary> /// <typeparam name="T">The type of the items in the <see cref="IEnumerable{T}"/>.</typeparam> /// <param name="source">The <see cref="IEnumerable{T}"/> to copy.</param> /// <param name="rand">The <see cref="Random"/> to use for number generation. Uses <see cref="TSRandom"/> if <see langword="null"/>.</param> public static IEnumerable <T> Shuffle <T>(this IEnumerable <T> source, Random rand = null) { GenericExtensions.ThrowIfNull(source, nameof(source)); rand ??= TSRandom.Instance; // Thread-safe random return(source.ShuffleIterator(rand)); }
public TestClassBuilder() : base(new TestClass()) { DefaultValues = new Dictionary <string, Func <dynamic> > { { GenericExtensions.GetPropertyName <TestClass, TestClass>(tc => tc.MeToo), () => new TestClass() } }; }
public EnvironmentalWorldDataBuilder() : base(new EnvironmentalWorldData()) { DefaultValues = new Dictionary <string, Func <dynamic> > { { GenericExtensions.GetPropertyName <EnvironmentalWorldData, EnvironmentalCellGrid>(wd => wd.Grid), () => new EnvironmentalCellGrid(0) }, { GenericExtensions.GetPropertyName <EnvironmentalWorldData, SeasonalTime>(wd => wd.Season), () => SeasonalTime.Spring } }; }
public void Given_Null_Value_When_ThrowIfNullOrDefault_Invoked_Then_It_Should_Throw_Exception() { var value = (object)null; Action action = () => GenericExtensions.ThrowIfNullOrDefault(value); action.Should().Throw <ArgumentNullException>(); }
public void Given_Value_When_IsNullOrDefault_Invoked_Then_It_Should_Return_False() { var value = new object(); var result = GenericExtensions.IsNullOrDefault(value); result.Should().BeFalse(); }
public void Given_Null_Value_When_IsNullOrDefault_Invoked_Then_It_Should_Return_True() { var value = (object)null; var result = GenericExtensions.IsNullOrDefault(value); result.Should().BeTrue(); }
public void Given_Null_IsNullOrDefault_ShouldReturn_True() { var result = GenericExtensions.IsNullOrDefault((object)null); result.Should().BeTrue(); result = GenericExtensions.IsNullOrDefault(default(object)); result.Should().BeTrue(); }
public void Given_Null_ThrowIfNullOrDefault_ShouldThrow_Exception() { Action action = () => GenericExtensions.ThrowIfNullOrDefault((object)null); action.ShouldThrow <ArgumentNullException>(); action = () => GenericExtensions.ThrowIfNullOrDefault(default(object)); action.ShouldThrow <ArgumentNullException>(); }
private static void Part2() { int wx = 10, wy = -1, x = 0, y = 0; foreach (var line in input) { char action = line[0]; int value = int.Parse(line.Substring(1)); switch (action) { case 'N': wy -= value; break; case 'S': wy += value; break; case 'E': wx += value; break; case 'W': wx -= value; break; case 'R': case 'L': if ((action == 'R' && value == 90) || (action == 'L' && value == 270)) { GenericExtensions.Swap(ref wx, ref wy); wx *= -1; break; } if ((action == 'R' && value == 270) || (action == 'L' && value == 90)) { GenericExtensions.Swap(ref wx, ref wy); wy *= -1; break; } if (value == 180) { wx *= -1; wy *= -1; break; } break; case 'F': // move to the waypoint the given number of times x += (wx * value); y += (wy * value); break; default: break; } } Console.WriteLine($"\nPart 2: End at ({x},{y})"); Console.WriteLine($"Manhattan Distance: {(x, y).ManhattanDistance((0, 0))}"); }
public void Given_Default_Value_When_ThrowIfNullOrDefault_Invoked_Then_It_Should_Return_Result() { var value = new object(); var result = GenericExtensions.ThrowIfNullOrDefault(value); result .Should().NotBeNull() .And.BeOfType <object>(); }
public static void SkipIfContainsNestedProperties <T, TReturn>(this ModelStateDictionary modelState, Expression <Func <T, TReturn> > expression) { var propName = GenericExtensions.GetPropertyName(expression); modelState .Keys .Where(x => x.Contains(propName) && !x.Equals(propName)) .ToList() .ForEach(key => modelState[key].Errors.Clear()); }
public StandardWorldBuilder() : base(new StandardWorld()) { DefaultValues = new Dictionary <string, Func <dynamic> > { { GenericExtensions.GetPropertyName <StandardWorld, StandardWorldData>(w => w.Data), () => new StandardWorldData() }, { GenericExtensions.GetPropertyName <StandardWorld, IFindNeighbours <StandardCell, StandardCellGrid> >(w => w.NeighbourFinder), () => new OpenNeighbourFinder <StandardCell, StandardCellGrid>() }, { GenericExtensions.GetPropertyName <StandardWorld, ICalculateCell <StandardCell, StandardCellGrid, StandardWorldData> >(w => w.CellCalculator), () => new StandardCellCalculator() }, { GenericExtensions.GetPropertyName <StandardWorld, IGenerateWorld <StandardCell, StandardCellGrid, StandardWorldData, StandardWorld> >(w => w.WorldGenerator), () => new StandardWorldGenerator() } }; }
public void GetPropertyName_Field_IsName() { // arrange const string expected = nameof(TestClass.IAmMostDefinitelyNotAProperty); // act var result = GenericExtensions.GetPropertyName <TestClass, string>(tc => tc.IAmMostDefinitelyNotAProperty); // assert Assert.AreEqual(expected, result); }
public EnvironmentalWorldBuilder() : base(new EnvironmentalWorld()) { DefaultValues = new Dictionary <string, Func <dynamic> > { { GenericExtensions.GetPropertyName <EnvironmentalWorld, EnvironmentalWorldData>(w => w.Data), () => new StandardWorldData() }, { GenericExtensions.GetPropertyName <EnvironmentalWorld, IFindNeighbours <EnvironmentalCell, EnvironmentalCellGrid> >(w => w.NeighbourFinder), () => new OpenNeighbourFinder <EnvironmentalCell, EnvironmentalCellGrid>() }, { GenericExtensions.GetPropertyName <EnvironmentalWorld, ICalculateCell <EnvironmentalCell, EnvironmentalCellGrid, EnvironmentalWorldData> >(w => w.CellCalculator), () => new EnvironmentalCellCalculator(new Random()) }, { GenericExtensions.GetPropertyName <EnvironmentalWorld, IGenerateWorld <EnvironmentalCell, EnvironmentalCellGrid, EnvironmentalWorldData, EnvironmentalWorld> >(w => w.WorldGenerator), () => new EnvironmentalWorldGenerator() }, { GenericExtensions.GetPropertyName <EnvironmentalWorld, ICalculateSeason>(w => w.SeasonCalculator), () => new NoSeasonCalculator() } }; }
/// <summary> /// Returns the given array with the specified object added to the end. /// </summary> /// <typeparam name="T">The type of objects contained within the array.</typeparam> /// <param name="array">The array to add to.</param> /// <param name="item">The object to be added to the end of the array. The value can be null for reference types.</param> /// <returns></returns> public static T[] Add <T>(this T[] array, T item) { GenericExtensions.ThrowIfNull(array, nameof(array)); int oldLen = array.Length; Array.Resize(ref array, oldLen + 1); array[oldLen] = item; return(array); }
public void GetPropertyName_ComplexProperty_IsName() { // arrange const string expected = nameof(TestClass.MeToo); // act var result = GenericExtensions.GetPropertyName <TestClass, TestClass>(tc => tc.MeToo); // assert Assert.AreEqual(expected, result); }
public void GetPropertyName_PrimitiveProperty_IsName() { // arrange const string expected = nameof(TestClass.IAmAProperty); // act var result = GenericExtensions.GetPropertyName <TestClass, int>(tc => tc.IAmAProperty); // assert Assert.AreEqual(expected, result); }
/// <summary> /// Indexes the simple properties. /// </summary> private void IndexSimpleProperties() { foreach (PropertyInfo propertyInfo in FetchSimpleProperties()) { var csName = GetPropertyName(propertyInfo.Name, propertyInfo); var ciName = csName.ToUpper(); var propertyType = PropertyType.SIMPLE; if (GenericExtensions.IsIndexedType(propertyInfo.PropertyType)) { propertyType |= PropertyType.INDEXED; } if (GenericExtensions.IsMappedType(propertyInfo.PropertyType)) { propertyType |= PropertyType.MAPPED; } var prop = new SimpleMagicPropertyInfo( csName, propertyInfo, propertyInfo.GetGetMethod(), propertyInfo.GetSetMethod(), propertyType); AddOrUpdateProperty(csName, ciName, prop); } foreach (MethodInfo methodInfo in FetchSimpleAccessors()) { var csName = GetAccessorPropertyName(methodInfo); var ciName = csName.ToUpper(); var setter = GetSimpleMutator(csName, methodInfo.ReturnType); var propertyType = PropertyType.SIMPLE; if (GenericExtensions.IsIndexedType(methodInfo.ReturnType)) { propertyType |= PropertyType.INDEXED; } if (GenericExtensions.IsMappedType(methodInfo.ReturnType)) { propertyType |= PropertyType.MAPPED; } var prop = new SimpleMagicPropertyInfo( csName, methodInfo, methodInfo, setter, propertyType); AddOrUpdateProperty(csName, ciName, prop); } }
public bool TryOpenCoverageReport(string reportPath) { try { _report = GenericExtensions.ParseXml <CoverageSession>(reportPath); CoverageUpdated?.Invoke(this, EventArgs.Empty); return(true); } catch { return(false); } }
public void Given_Default_Value_When_IsNullOrDefault_Invoked_Then_It_Should_Return_True() { var value1 = default(object); var result1 = GenericExtensions.IsNullOrDefault(value1); result1.Should().BeTrue(); var value2 = default(int); var result2 = GenericExtensions.IsNullOrDefault(value2); result2.Should().BeTrue(); }
public async Task <bool> UploadExceptionAsync(SerializableException exception, bool force = false) { if (IsTelemetryEnabled || force) { GenericExtensions.Debug(); _editorContext.WriteToLog(Resources.ExceptionEncountered); _editorContext.WriteToLog(exception.GetDescription()); return(await UploadExceptionAsync(exception)); } else { return(false); } }
public Object GetBeanPropInternal(Object @object, String key) { try { var result = _fastMethod.Invoke(@object, null); return(GenericExtensions.FetchKeyedValue(result, key, null)); } catch (InvalidCastException e) { throw PropertyUtility.GetMismatchException(_fastMethod.Target, @object, e); } catch (TargetInvocationException e) { throw PropertyUtility.GetInvocationTargetException(_fastMethod.Target, e); } }
/// <summary> /// Returns the given array with the first occurence of the specified object removed. /// </summary> /// <typeparam name="T">The type of items contained within the array.</typeparam> /// <param name="array">The array to remove from.</param> /// <param name="item">The object to remove from the array. The value can be null for reference types.</param> /// <returns></returns> public static T[] Remove <T>(this T[] array, T item) { GenericExtensions.ThrowIfNull(array, nameof(array)); int removeIdx = Array.IndexOf(array, item); if (removeIdx > array.GetLowerBound(0) - 1) { T[] newArray = new T[array.Length - 1]; Array.Copy(array, 0, newArray, 0, removeIdx + 1); Array.Copy(array, removeIdx + 1, newArray, removeIdx + 1, array.Length - removeIdx); return(newArray); } return(array); }
/// <summary> /// Returns a new, combined array from the given arrays. /// </summary> /// <typeparam name="T">The type of the array.</typeparam> /// <param name="array">The first array to concatenate.</param> /// <param name="arrays">The additional arrays to concatenate.</param> /// <returns></returns> public static T[] Concat <T>(this T[] array, params T[][] arrays) { GenericExtensions.ThrowIfNull(array, nameof(array)); GenericExtensions.ThrowIfNull(arrays, nameof(arrays)); int offset = array.Length; Array.Resize(ref array, array.Length + arrays.Sum(a => a.Length)); foreach (T[] arr in arrays) { int len = arr.Length; Array.Copy(arr, 0, array, offset, len); offset += len; } return(array); }
/// <summary> /// Create a fragment event type. /// </summary> /// <param name="propertyType">property return type</param> /// <param name="genericType">property generic type parameter, or null if none</param> /// <param name="beanEventTypeFactory">for event types</param> /// <param name="publicFields">indicator whether classes are public-field-property-accessible</param> /// <returns>fragment type</returns> public static FragmentEventType CreateNativeFragmentType( Type propertyType, Type genericType, BeanEventTypeFactory beanEventTypeFactory, bool publicFields) { var isIndexed = false; if (propertyType.IsArray) { isIndexed = true; propertyType = propertyType.GetElementType(); } else if (propertyType.IsGenericDictionary()) { // Ignore this - technically enumerable } else if (propertyType.IsGenericEnumerable()) { propertyType = GenericExtensions .FindGenericEnumerationInterface(propertyType) .GetGenericArguments()[0]; isIndexed = true; #if false if (genericType == null) { return null; } propertyType = genericType; #endif } if (!propertyType.IsFragmentableType()) { return null; } EventType type = beanEventTypeFactory.GetCreateBeanType(propertyType, publicFields); return new FragmentEventType(type, isIndexed, true); }
public void WhenSourceIsNull_ThenThrowException() { Assert.Throws <ArgumentNullException>(() => GenericExtensions.InvokeMethod(null as object, "PrivateMethodReturnVoid")); }
public static CodegenExpression CastSafeFromObjectType( Type targetType, CodegenExpression value) { if (targetType == null) { return ConstantNull(); } if (targetType == typeof(object)) { return value; } if (value is CodegenExpressionConstantNull) { return value; } if ((value is CodegenExpressionConstant codegenExpressionConstant) && (codegenExpressionConstant.IsNull)) { return value; } if (targetType == typeof(void)) { throw new ArgumentException("Invalid void target type for cast"); } if (targetType == typeof(int)) { return ExprDotMethod(value, "AsInt32"); } else if (targetType == typeof(int?)) { return ExprDotMethod(value, "AsBoxedInt32"); } else if (targetType == typeof(long)) { return ExprDotMethod(value, "AsInt64"); } else if (targetType == typeof(long?)) { return ExprDotMethod(value, "AsBoxedInt64"); } else if (targetType == typeof(short)) { return ExprDotMethod(value, "AsInt16"); } else if (targetType == typeof(short?)) { return ExprDotMethod(value, "AsBoxedInt16"); } else if (targetType == typeof(byte)) { return ExprDotMethod(value, "AsByte"); } else if (targetType == typeof(byte?)) { return ExprDotMethod(value, "AsBoxedByte"); } else if (targetType == typeof(decimal)) { return ExprDotMethod(value, "AsDecimal"); } else if (targetType == typeof(decimal?)) { return ExprDotMethod(value, "AsBoxedDecimal"); } else if (targetType == typeof(double)) { return ExprDotMethod(value, "AsDouble"); } else if (targetType == typeof(double?)) { return ExprDotMethod(value, "AsBoxedDouble"); } else if (targetType == typeof(float)) { return ExprDotMethod(value, "AsFloat"); } else if (targetType == typeof(float?)) { return ExprDotMethod(value, "AsBoxedFloat"); } else if (targetType == typeof(bool)) { return ExprDotMethod(value, "AsBoolean"); } else if (targetType == typeof(bool?)) { return ExprDotMethod(value, "AsBoxedBoolean"); } else if (targetType == typeof(DateTime)) { return ExprDotMethod(value, "AsDateTime"); } else if (targetType == typeof(DateTime?)) { return ExprDotMethod(value, "AsBoxedDateTime"); } else if (targetType == typeof(DateTimeOffset)) { return ExprDotMethod(value, "AsDateTimeOffset"); } else if (targetType == typeof(DateTimeOffset?)) { return ExprDotMethod(value, "AsBoxedDateTimeOffset"); } else if (targetType == typeof(FlexCollection)) { return StaticMethod(typeof(FlexCollection), "Of", value); } else if (targetType == typeof(IDictionary<string, object>)) { return StaticMethod(typeof(CompatExtensions), "AsStringDictionary", value); } else if (targetType == typeof(IDictionary<object, object>)) { return StaticMethod(typeof(CompatExtensions), "AsObjectDictionary", value); } else if (targetType.IsGenericDictionary()) { return Cast(targetType, value); } else if (targetType.IsArray()) { var elementType = targetType.GetElementType(); return StaticMethod(typeof(CompatExtensions), "UnwrapIntoArray", new[] {elementType}, value); } else if (targetType.IsGenericList()) { var elementType = GenericExtensions.GetCollectionItemType(targetType); return StaticMethod(typeof(CompatExtensions), "UnwrapIntoList", new [] {elementType}, value); } else if (targetType.IsGenericSet()) { var elementType = GenericExtensions.GetCollectionItemType(targetType); return StaticMethod(typeof(CompatExtensions), "UnwrapIntoSet", new [] {elementType}, value); } else if (targetType == typeof(ICollection<object>)) { return StaticMethod(typeof(TypeHelper), "AsObjectCollection", value); } else if (targetType.IsGenericCollection()) { var elementType = GenericExtensions.GetCollectionItemType(targetType); return Unwrap(elementType, value); } return Cast(targetType, value); }
private JsonSerializationForgePair GetForgePair( Type type, IDictionary <Type, JsonApplicationClassSerializationDesc> classSerializationDescs) { type = type.GetBoxedType(); // Search for a pre-built pair. Please change this logic so that built-in types are // done in pairs. if (_forgePairs.TryGetValue(type, out var forgePair)) { return(forgePair); } // The type was not found as a pre-built pair. Examine the data type and attempt to create // the right pair of forges for this type. if (type.IsEnum) { return(new JsonSerializationForgePair( JsonSerializerForgeStringWithToString.INSTANCE, new JsonDeserializerForgeEnum(type))); } if (type.IsArray) { var componentType = type.GetElementType(); var componentForgePair = GetForgePair(componentType, classSerializationDescs); return(new JsonSerializationForgePair( new JsonSerializerForgeArray(componentForgePair.SerializerForge, componentType), new JsonDeserializerForgeArray(componentForgePair.DeserializerForge, componentType))); } if (type.IsGenericStringDictionary()) { var valueType = type.GetDictionaryValueType(); var valueTypeForgePair = GetForgePair(valueType, classSerializationDescs); return(new JsonSerializationForgePair( new JsonSerializerForgePropertyMap( valueTypeForgePair.SerializerForge, valueType), new JsonDeserializerForgePropertyMap( valueTypeForgePair.DeserializerForge, valueType))); } if (type.IsGenericList() || type.IsGenericEnumerable()) { var genericType = GenericExtensions.GetComponentType(type); if (genericType == null) { return(null); } var genericForgePair = GetForgePair(genericType, classSerializationDescs); return(new JsonSerializationForgePair( new JsonSerializerForgeArray(genericForgePair.SerializerForge, genericType), new JsonDeserializerForgeArray(genericForgePair.DeserializerForge, genericType))); } if (classSerializationDescs.TryGetValue(type, out JsonApplicationClassSerializationDesc existingDesc)) { return(new JsonSerializationForgePair( new JsonSerializerForgeByClassName(existingDesc.SerializerClassName), new JsonDeserializerForgeByClassName(existingDesc.DeserializerClassName))); } //throw new ArgumentException($"unable to determine forge pair for type {type.CleanName()}"); return(null); }