public void MatchWithEscape() { string pattern = @"http://bla.de?hiho.x={(\d+)}"; string value = PatternMatching.MatchEmbeddedRegex(pattern, "http://bla.de?hiho.x=438"); Assert.AreEqual("438", value); }
public void NoEmbeddedRegEx() { string pattern = @"http://bla.de?hiho.x="; string value = PatternMatching.MatchEmbeddedRegex(pattern, "http://bla.de?hiho.x="); Assert.AreEqual(null, value); }
async static Task Main(string[] args) { Console.WriteLine("\n=== IndicesAndRanges ==="); IndicesAndRanges.Demo(); Console.WriteLine("\n=== SwitchExpressions ==="); SwitchExpressions.Demo(); Console.WriteLine("\n=== PatternMatching ==="); PatternMatching.Demo(); Console.WriteLine("\n=== StaticLocalFunctions ==="); StaticLocalFunctions.Demo(); Console.WriteLine("\n=== UsingDeclarations ==="); UsingDeclarations.Demo(); Console.WriteLine("\n=== AsyncStreams ==="); await AsyncStreams.Demo(); Console.WriteLine("\n=== TargetTypedNew ==="); TargetTypedNew.Demo(); Console.WriteLine("\n=== NullCoallescingAssignment ==="); NullCoallescingAssignment.Demo(); Console.WriteLine("\n=== DefaultInterfaceMethods ==="); DefaultInterfaceMethods.Demo(); Console.WriteLine("\n=== DisposableRefStruct ==="); DisposableRefStruct.Demo(); Console.WriteLine("\n=== UnmanagedConstructedTypes ==="); UnmanagedConstructedTypes.Demo(); }
public static void PartThreeStart() { int amount = 50; string splitter = "="; Program.center(amount, "Start of The Third Part", "*"); ////////////////////////////////////////////// Program.center(amount, "Extinsions", splitter); Extinsions extinsions = new Extinsions(); extinsions.StartExample(); ////////////////////////////////////////////// Program.center(amount, "Partial methods and classes", splitter); StartPartial.StartExample(); ////////////////////////////////////////////// Program.center(amount, "Anon types", splitter); AnonoimoysTypes.StartExample(); ////////////////////////////////////////////// Program.center(amount, "Local functions", splitter); LocalFunctions.StartExample(); ////////////////////////////////////////////// Program.center(amount, "Deconstruction for beginers", splitter); Deconstruction.StartExample(); ////////////////////////////////////////////// Program.center(amount, "Pattern matching", splitter); PatternMatching.StartExample();//// ////////////////////////////////////////////// Program.center(amount, "Nullable Types", splitter); NullableTypes.StartExample(); ////////////////////////////////////////////// Program.center(amount, "Reference vars", splitter); ReferenceVars.StartExample(); ////////////////////////////////////////////// }
public void MatchSimpleString() { string pattern = @"hiho{(\d+)}bla"; string value = PatternMatching.MatchEmbeddedRegex(pattern, "hiho1234bla"); Assert.AreEqual("1234", value); }
public void NotMatched() { string pattern = @"http://bla.de?hiho.x={(\d+)}"; string value = PatternMatching.MatchEmbeddedRegex(pattern, "http://bla.de?hiho.x=bfd"); Assert.AreEqual(null, value); }
public void HandlesExceptionForDefaultCase() { // Arrange var patternMatching = new PatternMatching(); // Act | Assert Assert.Throws <ArgumentNullException>("machine", () => patternMatching.MatchingMachineProduct(null)); }
public void ClassA_With_Name_IsMatched() { var x = new ClassA(); x.Name = "upendra"; var result = PatternMatching.Match(x); Assert.True(result == "ClassA.upendra"); }
public void Run() { List <Shape> shapes = new() { new Circle(), new Rectangle() }; foreach (var shape in shapes) { PatternMatching.DisplayShape(shape); } }
public void AddTest() { int?x = 1; int?y = 1; int?z = null; Assert.That(PatternMatching.Add(x, y), Is.EqualTo(2)); Assert.That(PatternMatching.Add(x, z), Is.EqualTo(1)); Assert.That(PatternMatching.Add(z, y), Is.EqualTo(1)); Assert.That(PatternMatching.Add(z, z), Is.EqualTo(0)); }
static void Main(string[] args) { Console.WriteLine("RelationalPatterns"); RelationalPatterns.Run(); Console.WriteLine("PatternMatching"); PatternMatching.Run(); Console.WriteLine("PatternCombinators"); PatternCombinators.Run(); Console.ReadLine(); }
public void MatchesPizzaPatternInSwitch() { // Arrange var patternMatching = new PatternMatching(); IMachine pizza = new PizzaMachine(); // Act var result = patternMatching.MatchingMachineProduct(pizza); // Assert Assert.Equal("Pizza", result); }
public void MatchesFishAndChipsPatternInSwitch() { // Arrange var patternMatching = new PatternMatching(); IMachine fishAndChips = new FishAndChipsMachine(); // Act var result = patternMatching.MatchingMachineProduct(fishAndChips); // Assert Assert.Equal("Fish and chips", result); }
public void MatchesNotInCasePatternInSwitch() { // Arrange var patternMatching = new PatternMatching(); IMachine notInCase = new NotInCaseMachine(); // Act var result = patternMatching.MatchingMachineProduct(notInCase); // Assert Assert.Equal(null, result); }
public override IEnumerable <MatchResult> Match(Value v, MatchContext context) { if (!(v is ExpressionValue expr)) { return(new MatchResult[0]); } return(_head.Match(expr.Head, context) .SelectMany(res => PatternMatching.SequenceMatch(_parts, expr.Parts, res.Context) .Select(partRes => partRes.Context.WithMatch(_engine.Expr( _engine.PatternMatching.ToSingle(res.SequenceMatch), partRes.SequenceMatch ))))); }
public OsmiumEngine() { _symTab = new SymbolTable(this); _evaluator = new Evaluator(this); PatternMatching = new PatternMatching(this); System = new SystemSymbols(this); Context = "Global`"; Zero = new IntegerValue(this, BigInteger.Zero); One = new IntegerValue(this, BigInteger.One); MinusOne = new IntegerValue(this, BigInteger.MinusOne); Null = System.Null; True = System.True; False = System.False; ContextPath = new List <string> { "System`" }; }
static void Main() { //0. Attributes on Properties AttributesOnProperties.Run(); //1. Readonly members ReadonlyMembers.Run(); //2. Default interface methods DefaultInterfaceMethods.Run(); //3. Patterns matching PatternMatching.Run(); //4. Using Declarations UsingDeclarations.Run(); //5. Static Local Functions StaticLocalFunctions.Run(); //6. Disposable ref structs DisposableRefStructs.Run(); //7. Nullable Reference Types NullableReferenceTypes.Run(); //8. Asynchronous streams AsynchronousStreams.Run(); //9. Asynchronous disposable AsynchronousDisposable.Run(); //10. Indeces And Ranges IndecesAndRanges.Run(); //11. Null-coalescing assignment NullCoalescingAssignment.Run(); //12. Nested Stackalloc NestedStackalloc.Run(); //13. Enhancement of interpolated verbatim strings InterpolatedVerbatimStringsEnhancement.Run(); }
static void Main(string[] args) { BinaryLiteralsAndDigitSeparators binaryLiteralsAndDigitSeparators = new BinaryLiteralsAndDigitSeparators(); binaryLiteralsAndDigitSeparators.Run(); RefLocalsAndReturns refLocalsAndReturns = new RefLocalsAndReturns(); refLocalsAndReturns.Run(); Deconstruction deconstruction = new Deconstruction(); deconstruction.Run(); PatternMatching patternMatching = new PatternMatching(); patternMatching.Run(); Tuples tuples = new Tuples(); tuples.Run(); }
static async Task Main(string[] args) { var result = await Tupler.ProcessLanguage(); //Review 1 Null Conditional var nullConditional = new NullConditional(); nullConditional.PurchaseProduct(); //nifty way of checking argument length switch (args?.Length) { case 1: //one arg passed in break; case 2: //you get the idea break; } //2 Interpolation Interpolation.InterpolateDemo(); //3 Null conditional var nc = new NullConditional(); nc.PurchaseProduct(); //As you see fit... //***************************************************** //1. Binary Literal and digit separator DigitAndBinary.Process(); //***************************************************** //2. Ref returns - pointer to a structure //Cannot use with async. Compiler can't know if ref'd variable is set before it returns var refReturns = new RefReturnsAndLocal(); refReturns.TestRefs(); //***************************************************** //3. Expression bodied accessors, constructors, destructor/finalizer // C# 6 var zombie = new CSharp6.ExpressionBodied6.Zombie("Fred", 30); Console.WriteLine(zombie.ToString()); //3a. Note C#6 collection initialization List <Order> orders = new List <Order>() { new Order(), new Order(), new Order() }; var processor = new OrderProcessor(orders); //4 //Throw expressions - allow throw in expression bodied methods // (these could be used all throughout api stubs, like reference assemblies for compilation) //Also allows null coalescing (single line function calls) try { var person = new CSharp7.Person(null); } catch (Exception ex) { Console.WriteLine($"Caught throw expression:{ex}"); } //***************************************************** //4. Local Functions int[] numbers = { 3, 8, 7, 5, 2, 1, 9, 6, 4 }; LocalFunctions.QuickSort(numbers, 0, numbers.Length - 1); Console.WriteLine("Sorted items"); numbers.ToList().ForEach(o => Console.WriteLine(o)); //Ex 2 LocalFunctions.Fibonacci(5); //***************************************************** //5. Out vars OutVars.Process(); //***************************************************** //6. Pattern Matching var pm = new PatternMatching(); pm.MatchSomething(new Circle(3.5d)); pm.MatchSomething(new Rectangle(2d, 4d)); //Int pm.PrintStars(5); //String pm.PrintStars("5"); //Shape pm.PrintStars(new Rectangle(3, 4)); //***************************************************** //8. Tuples //Now a valuetuple - NO GC PRESSURE. Stack based! //Lets check it out //https://docs.microsoft.com/en-us/dotnet/api/?view=netframework-4.6.2&term=ValueTuple //https://docs.microsoft.com/en-us/dotnet/api/?view=netframework-4.5&term=System.Tuple //Literals - note IL is optimized // [130 13 - 130 53] // IL_01c3: ldc.i4.1 // IL_01c4: stloc.s a // IL_01c6: ldc.i4.2 // IL_01c7: stloc.s b var(a, b, c, c1, c2) = (1, 2, 3, 4, 5); //We have variables now var addThemUp = a + b + c; //Tuple compatibility with System.Tuple (var userName, var pass) = Tuple.Create("adam", "91281821JASJHDAHssh2#h4H#H@#Hh2h3H#H"); //Type inference - note right hand side intellisense (float i, int j, int k) = (1, 2, 3); //named (int p, int q, int r)theTup = (2, 3, 4); theTup = (5, 6, 7); theTup.p = 8; //adam var adam = ("adam", "m", "tuliper"); //123-44-1234 (string firstName, string middleName, string lastName)cestMoi = adam; //If we don't care about names (string, string, string)stringTuple = default((string tup1, string tup2, string tup3)); stringTuple.Item1 = "Mary"; //var result = task.Result; Console.WriteLine($"{result.keyPhrases}\r\n{result.sentiment}\r\n{result.language}"); //named type inference var speedAndHealth = (health : 100, speed : 10); //This isn't meant to be hungarian notation :) (int id1, int id2, int id3)t = (2, 3, 4); Console.WriteLine($"{t.id1} {t.id2} {t.id3}"); //can't convert dbl to float, and also a:1 - 'a' will be ignored //(int a1, float b1, int c20) conversions = (a: 1, 2d, 3); var item = (num : 1f, count : 2f, name : "hello", person : new Person() { Name = "Mary" }); item.Item1 = item.Item2 * item.Item1; //Tuple.Create("item1", "item2", "item", "item", "item", "item", "item7", Tuple.Create("item 8")) // .Set(out var item1, out var item2, out var item3, out var item4, out var item5, out var item6, out var item7) // .Set(out var item8); //8b. Deconstruction var point = new Point(5, 4); var(p1, p2) = point; //overloaded deconstruction var(x1, y1, q1) = point; //Note can't have a single value deconstruction or tuple //(int aqqqq) = (5); //Deconstruction, I only want one item (int a10, _, _, _, _) = (1, 2, 3, 4, 5); var(x, _) = point; //Equality - checks var(first, address) = ("1", "2"); return; }
protected override JobHandle OnUpdate(JobHandle jobs) { if (viewCmdStack.Count > 0) { return(jobs); } if (patternMatchRequest.IsCreated) { unswap.Clear(); } var blocksToDelete = new NativeArray <int>(100, Allocator.TempJob); var jobCmdBuffer = cmdBuffer.CreateCommandBuffer().ToConcurrent(); var swapTestJob = new SwapTest() { level = EntityManager.GetBuffer <Level>(levelEntity), levelInfo = levelInfo, cmdBuff = jobCmdBuffer, patternMatchRequest = patternMatchRequest.ToConcurrent(), viewCmdStack = viewCmdStack.ToConcurrent() }; var patternMatching = new PatternMatching() { patternsBufferLookup = GetBufferFromEntity <Pattern>(isReadOnly: true), patternMatchRequest = patternMatchRequest, patternsInfo = patterns, levelBufferLookup = GetBufferFromEntity <Level>(isReadOnly: true), levelInfo = levelInfo, blocksToDelete = blocksToDelete, unswap = unswap.ToConcurrent() }; var performSwap = new PerformSwap() { level = EntityManager.GetBuffer <Level>(levelEntity), levelInfo = levelInfo, unswap = unswap, cmdBuffer = jobCmdBuffer, viewCmdStack = viewCmdStack.ToConcurrent() }; var deleteBlocks = new DeleteBlock() { blocksToDelete = blocksToDelete, levelBufferLookup = GetBufferFromEntity <Level>(isReadOnly: false), levelInfo = levelInfo, cmdBuffer = jobCmdBuffer, viewCmdStack = viewCmdStack.ToConcurrent() }; var moveDownBlocks = new MoveDownBlocks() { levelInfo = levelInfo, levelBufferLookup = GetBufferFromEntity <Level>(isReadOnly: false), viewCmdStack = viewCmdStack.ToConcurrent(), patternMatchRequest = patternMatchRequest.ToConcurrent() }; jobs = swapTestJob.Schedule(this, jobs); jobs = patternMatching.Schedule(jobs); jobs = performSwap.Schedule(this, jobs); jobs = deleteBlocks.Schedule(blocksToDelete.Length, 2, jobs); jobs = moveDownBlocks.Schedule(levelInfo.size.x, 2, jobs); return(jobs); }
static void Main(string[] args) { (string p1, string p2, string keyLang, string keyNum) = (null, null, "", ""); switch (args?.Length) { case 1: p1 = args[0]; break; case 2: p2 = args[1]; goto case 1; } if (!string.IsNullOrEmpty(p1)) { Console.WriteLine("Demo Language (C# X) [5=C#5, 6=C#6, 7=C#7.0, 1=C#7.1, 2=C#7.2, 3=C#7.3"); keyLang = Console.ReadKey().KeyChar.ToString(); } else { keyLang = p1; } Console.WriteLine(); if (!string.IsNullOrEmpty(p2)) { Console.WriteLine("Demo Number (1-F)"); keyNum = Console.ReadKey().KeyChar.ToString().ToUpper(); } else { keyNum = p2; } Console.WriteLine($"Call demo: {keyLang}.{keyNum}"); switch ($"{keyLang}.{keyNum}") { case "5.1": Console.WriteLine("Async Await"); break; case "5.2": Console.WriteLine("Async Load"); break; case "5.3": Console.WriteLine("CallerInfo"); break; case "6.1": Console.WriteLine("Auto Props"); break; case "6.2": Console.WriteLine("Collection Initializer"); break; case "6.3": Console.WriteLine("Dictionaries"); break; case "6.4": Console.WriteLine("Exception Filter"); break; case "6.5": Console.WriteLine("ExpressionBodies"); var eb = new ExpressionBodies.Zombie("Some Name", 100); Console.WriteLine($"Health = {eb.Health}; Name = {eb.Name}"); break; case "6.6": Console.WriteLine("Index Init"); break; case "6.7": Console.WriteLine("Interpolation"); //2 Interpolation Interpolation.InterpolateDemo(); break; case "6.8": Console.WriteLine("NameOf"); break; case "6.9": Console.WriteLine("Null Conditional"); break; case "6.10": Console.WriteLine("Partial Interface"); //Review 1 Null Conditional var nullConditional = new NullConditional(); nullConditional.PurchaseProduct(); break; case "6.11": Console.WriteLine("Using Static"); break; case "7.0": Console.WriteLine("DigitAndBinary"); //1. Binary Literal and digit separator DigitAndBinary.Process(); break; case "7.1": Console.WriteLine("RefReturnAndOuts"); //2. Ref returns - pointer to a structure var refReturns = new RefReturnsAndOuts(); refReturns.TestRefs(); break; case "7.2": Console.WriteLine("ExpressionBodied"); //3. Expression bodied accessors, constructors, destructor/finalizer // C# 6 var zombie = new CSharp6.ExpressionBodies.Zombie("Fred", 30); Console.WriteLine(zombie.ToString()); break; case "7.3": Console.WriteLine("LocalFunction"); break; case "7.4": Console.WriteLine("Local Functions"); int[] numbers = { 3, 8, 7, 5, 2, 1, 9, 6, 4 }; LocalFunctions.QuickSort(numbers, 0, numbers.Length - 1); Console.WriteLine("Sorted items"); numbers.ToList().ForEach(o => Console.WriteLine(o)); //Ex 2 LocalFunctions.Fibonacci(5); break; case "7.5": OutVars.Process(); break; case "7.6": Console.WriteLine("PatternMatching"); //6. Pattern Matching var pm = new PatternMatching(); pm.MatchSomething(new Circle(3.5d)); pm.MatchSomething(new Rectangle(2d, 4d)); //Int pm.PrintStars(5); //String pm.PrintStars("5"); //Shape pm.PrintStars(new Rectangle(3, 4)); break; case "7.7": Console.WriteLine("ThrowExpression"); try { Person p = new Person(""); p.Name = null; // throws an exception } catch (Exception) { Console.WriteLine("Exception thrown"); } break; case "7.8": Console.WriteLine("Tupler"); var task = Tupler.ProcessPageRead(); task.Wait(); var result = task.Result; Console.WriteLine($"{result.url} sent {result.data.Length} bytes"); break; case "7.9": Console.WriteLine("Deconstruct"); break; case "7.A": Console.WriteLine("GeneralizedAsyncReturn"); break; // C# 7.1 case "1.1": break; case "1.2": break; case "1.3": var dil = new DiscardsInLambdas(); dil.Run(); break; case "1.4": break; case "1.5": break; case "1.6": var tt = new TargetTypedDefault(); Console.WriteLine($"Ausgabe: {tt.DoSomething()}"); // 0 break; case "1.7": var tp = new TupleProjectionInitializers(); tp.Run(); break; // C# 7.2 case "2.1": Console.WriteLine("ExpressionVariablesInInit"); break; case "2.2": Console.WriteLine("MixedNamedArguments"); MixedNamedArguments.Execute(); break; case "2.3": Console.WriteLine("ReferenceSemanticsIn"); break; // C# 7.3 case "3.3": Console.WriteLine("Tuples Equality"); break; } Console.WriteLine(); Console.ReadLine(); }
private static void PatternMatching() { var patternMatching = new PatternMatching(); patternMatching.PrintPatternMatching(); }
//public override NodeType NodeType { // get { return NodeType.Member; } //} protected bool MatchMember(MemberDeclaration o, PatternMatching.Match match) { return MatchAttributesAndModifiers(o, match) && this.ReturnType.DoMatch(o.ReturnType, match) && this.PrivateImplementationType.DoMatch(o.PrivateImplementationType, match) && MatchString(this.Name, o.Name); }
protected bool MatchAttributesAndModifiers (AttributedNode o, PatternMatching.Match match) { return (this.Modifiers == Modifiers.Any || this.Modifiers == o.Modifiers) && this.Attributes.DoMatch (o.Attributes, match); }
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) { CSharpModifierToken o = other as CSharpModifierToken; return o != null && this.modifier == o.modifier; }
public void RegExMatchingTests(string s, string p, bool result) { var pm = new PatternMatching(); Assert.Equal(result, pm.IsMatch(s, p)); }
public bool IsMatch(Value pattern, Value what) { return(PatternMatching.IsMatch(pattern, what)); }
public void Null_IsMatched() { Assert.Throws <ArgumentNullException>(() => PatternMatching.Match(null)); }
public static void Main(string[] args) { int option = 1; int i_option = 1; int ii_option = 1; // YO AMO A MI ESPOSA :) LE VOY A COMPRAR MUCHOS REGALOS :) while (option != 0) { ConsoleUtility.WriteLine("Choose an option based in the next menu"); ConsoleUtility.WriteLine("1.-Algorithm"); ConsoleUtility.WriteLine("2.-DataStructures"); ConsoleUtility.WriteLine("3.-Design Patterns"); ConsoleUtility.WriteLine("4.-Language DotNet"); option = Convert.ToInt32(Console.ReadLine()); switch (option) { case 1: ConsoleUtility.WriteLine("Algorithm"); ConsoleUtility.WriteLine("1.-Linear Table"); ConsoleUtility.WriteLine("2.-Linear Table Append"); ConsoleUtility.WriteLine("3.-Linear Table Delete"); ConsoleUtility.WriteLine("4.-Linear Table Insert"); ConsoleUtility.WriteLine("5.-Linear Table Search"); ConsoleUtility.WriteLine("6.-Factorial"); ConsoleUtility.WriteLine("7.-Bubble Sort"); ConsoleUtility.WriteLine("8.-Heap Sort"); ConsoleUtility.WriteLine("9.-Insert Sorting"); ConsoleUtility.WriteLine("10.-Merge Sort"); ConsoleUtility.WriteLine("11.-Quick Sort"); ConsoleUtility.WriteLine("12.-Select Sort"); ConsoleUtility.WriteLine("13.-Binary Search"); ConsoleUtility.WriteLine("14.-Fibonnacci"); ConsoleUtility.WriteLine("15.-Fibonacci with Memoization"); i_option = Convert.ToInt32(Console.ReadLine()); switch (i_option) { case 1: ConsoleUtility.WriteLine("Running example of Linear Table"); LinearTable linearTable = new LinearTable(); linearTable.Run(); break; case 2: ConsoleUtility.WriteLine("Running example of Linear Table Append"); LinearTableAppend linearTableAppend = new LinearTableAppend(); linearTableAppend.Run(); break; case 3: ConsoleUtility.WriteLine("Running example of Linear Table Delete"); LinearTableDelete linearTableDelete = new LinearTableDelete(); linearTableDelete.Run(); break; case 4: ConsoleUtility.WriteLine("Running example of Linear Table Insert"); LinearTableInsert linearTableInsert = new LinearTableInsert(); linearTableInsert.Run(); break; case 5: ConsoleUtility.WriteLine("Running example of Linear Table Search"); LinearTableSearch linearTableSearch = new LinearTableSearch(); linearTableSearch.Run(); break; case 6: ConsoleUtility.WriteLine("Running example of Factorial"); Factorial factorial = new Factorial(); factorial.Run(); break; case 7: ConsoleUtility.WriteLine("Running example of Bubble Sort"); BubbleSort bubbleSort = new BubbleSort(); bubbleSort.Run(); break; case 8: ConsoleUtility.WriteLine("Running example of HeapSort"); HeapSort heapSort = new HeapSort(); heapSort.Run(); break; case 9: ConsoleUtility.WriteLine("Running example of InsertSorting"); InsertSorting insertSorting = new InsertSorting(); insertSorting.Run(); break; case 10: ConsoleUtility.WriteLine("Running example of Merge Sort"); MergeSort mergeSort = new MergeSort(); mergeSort.Run(); break; case 11: ConsoleUtility.WriteLine("Running example pf Quick Sort"); QuickSort quickSort = new QuickSort(); quickSort.Run(); break; case 12: ConsoleUtility.WriteLine("Running example of Select Sort"); SelectSort selectSort = new SelectSort(); selectSort.Run(); break; case 13: ConsoleUtility.WriteLine("Running example of Binary Search"); BinarySearch binarySearch = new BinarySearch(); binarySearch.Run(); break; case 14: ConsoleUtility.WriteLine("Running example of Fibonnacci"); Fibonnacci fibonnacci = new Fibonnacci(); fibonnacci.Run(); break; case 15: ConsoleUtility.WriteLine("Running example of Fibonnaci with Memoization"); FibonacciMemoization fibonacciMemoization = new FibonacciMemoization(); fibonacciMemoization.Run(); break; default: break; } break; case 2: ConsoleUtility.WriteLine("Data Structures"); ConsoleUtility.WriteLine("1.-Binary Search Tree"); ConsoleUtility.WriteLine("2.-Binary Tree"); ConsoleUtility.WriteLine("3.-Doubly Linked List"); ConsoleUtility.WriteLine("4.-Double Linked List"); ConsoleUtility.WriteLine("5.-Hash Table"); ConsoleUtility.WriteLine("6.-Linked List"); ConsoleUtility.WriteLine("7.-One Way Circular List"); ConsoleUtility.WriteLine("8.-Queue"); ConsoleUtility.WriteLine("9.-Stack"); ConsoleUtility.WriteLine("10.-Two Way Circular List"); ConsoleUtility.WriteLine("11.-Unidirectional Linked List"); i_option = Convert.ToInt32(Console.ReadLine()); ConsoleUtility.WriteLine($"you choose option {i_option}"); switch (i_option) { case 1: ConsoleUtility.WriteLine("Running example of Binary Search Tree"); BinarySearchTree binarySearchTree = new BinarySearchTree(); binarySearchTree.Run(); break; case 2: ConsoleUtility.WriteLine("Running example of Binary Tree"); BinaryTree binaryTree = new BinaryTree(); binaryTree.Run(); break; case 3: ConsoleUtility.WriteLine("Running example of DoublyLinkedList"); DoublyLinkedList doublyLinkedList = new DoublyLinkedList(); doublyLinkedList.Run(); break; case 4: ConsoleUtility.WriteLine("Running example of DoubleLinkedList"); DoubleLinkedList doubleLinkedList = new DoubleLinkedList(); doubleLinkedList.Run(); break; case 5: ConsoleUtility.WriteLine("Running example of HashTable"); HashTable hashTable = new HashTable(); hashTable.Run(); break; case 6: ConsoleUtility.WriteLine("Running example of Linked List"); LinkedList <int> linkedList = new LinkedList <int>(); linkedList.Run(); break; case 7: ConsoleUtility.WriteLine("Running example of One Way Circular List"); OneWayCircularList circularList = new OneWayCircularList(); circularList.Run(); break; case 8: ConsoleUtility.WriteLine("Running example of Queue"); Queue queue = new Queue(); queue.Run(); break; case 9: ConsoleUtility.WriteLine("Running example of Stack"); Stack stack = new Stack(); stack.Run(); break; case 10: ConsoleUtility.WriteLine("Running example of Two Way Circular List"); TwoWayCircularList twoWay = new TwoWayCircularList(); twoWay.Run(); break; case 11: ConsoleUtility.WriteLine("Running example fo Unidirectional Linked List"); UnidirectionalLinkedList unidirectionalLinkedList = new UnidirectionalLinkedList(); unidirectionalLinkedList.Run(); break; default: break; } break; case 3: ConsoleUtility.WriteLine("Design Patterns"); ConsoleUtility.WriteLine("1.-Creational"); ConsoleUtility.WriteLine("2.-Structural"); ConsoleUtility.WriteLine("3.-Behavioral"); ConsoleUtility.WriteLine("4.-SOLID Principles"); i_option = Convert.ToInt32(Console.ReadLine()); ConsoleUtility.WriteLine($"you choose option {i_option}"); switch (i_option) { case 1: ConsoleUtility.WriteLine("Example of creational design patterns"); ConsoleUtility.WriteLine("1.-Singleton"); ConsoleUtility.WriteLine("2.-Factory"); ConsoleUtility.WriteLine("3.-Builder"); ConsoleUtility.WriteLine("4.-Prototype"); ConsoleUtility.WriteLine("5.-Fluent Interface"); ConsoleUtility.WriteLine("6.-Factory Method"); ConsoleUtility.WriteLine("7.-Abstract Factory"); ConsoleUtility.WriteLine("Select one option"); ii_option = Convert.ToInt32(Console.ReadLine()); switch (ii_option) { case 1: ConsoleUtility.WriteLine("Running example of singleton design pattern"); SingletonTest singletonTest = new SingletonTest(); singletonTest.Run(); break; case 2: ConsoleUtility.WriteLine("Runnig example of Factory design pattern"); FactoryTest factoryTest = new FactoryTest(); factoryTest.Run(); break; case 3: ConsoleUtility.WriteLine("Running example fo Builder Desiogn Pattern"); BuilderTest builderTest = new BuilderTest(); builderTest.Run(); break; case 4: ConsoleUtility.WriteLine("Running example of Prototype Design Pattern"); PrototypeTest prototype = new PrototypeTest(); prototype.Run(); break; case 5: ConsoleUtility.WriteLine("Running example of Fluent Interface Design Patter"); FluentInterface fluent = new FluentInterface(); fluent.Run(); break; case 6: ConsoleUtility.WriteLine("Running example of Factory Method Design Pattern"); FactoryMethodTest factory = new FactoryMethodTest(); factory.Run(); break; case 7: ConsoleUtility.WriteLine("Running example of Abstract Factory"); AbstractFactoryTest abstractFactory = new AbstractFactoryTest(); abstractFactory.Run(); break; default: break; } break; case 2: ConsoleUtility.WriteLine("Example of Structural Design Pattern"); ConsoleUtility.WriteLine("1.-Adapter"); ConsoleUtility.WriteLine("2.-Facade"); ConsoleUtility.WriteLine("3.-Decorator"); ConsoleUtility.WriteLine("4.-Composite"); ConsoleUtility.WriteLine("5.-Proxy"); ConsoleUtility.WriteLine("6.-Flyweight"); ConsoleUtility.WriteLine("7.-Bridge"); ii_option = Convert.ToInt32(Console.ReadLine()); switch (ii_option) { case 1: ConsoleUtility.WriteLine("Running example of Adapter"); AdapterTest adapter = new AdapterTest(); adapter.Run(); break; case 2: ConsoleUtility.WriteLine("Running example of Facade"); FacadeTest facade = new FacadeTest(); facade.Run(); break; case 3: ConsoleUtility.WriteLine("Running example of Decorator"); DecoratorTest decorator = new DecoratorTest(); decorator.Run(); break; case 4: ConsoleUtility.WriteLine("Running example of Composite"); CompositeTest composite = new CompositeTest(); composite.Run(); break; case 5: ConsoleUtility.WriteLine("Running example of Proxy"); ProxyTest proxy = new ProxyTest(); proxy.Run(); break; case 6: ConsoleUtility.WriteLine("Running example of Flyweight"); FlyweightTest flyweight = new FlyweightTest(); flyweight.Run(); break; case 7: ConsoleUtility.WriteLine("Running example of Bridge"); BridgeTest bridge = new BridgeTest(); bridge.Run(); break; default: break; } break; case 3: ConsoleUtility.WriteLine("Example of Behavioral Design Pattern"); ConsoleUtility.WriteLine("1.-Chain of Responsability"); ConsoleUtility.WriteLine("2.-Command"); ConsoleUtility.WriteLine("3.-Observer"); ConsoleUtility.WriteLine("4.-Iterator"); ConsoleUtility.WriteLine("5.-State"); ConsoleUtility.WriteLine("6.-Template Method"); ConsoleUtility.WriteLine("7.-Visitor"); ConsoleUtility.WriteLine("8.-Strategy"); ConsoleUtility.WriteLine("9.-Mediator"); ConsoleUtility.WriteLine("10.-Memento"); ConsoleUtility.WriteLine("11.-Interpreter"); ii_option = Convert.ToInt32(Console.ReadLine()); switch (ii_option) { case 1: ConsoleUtility.WriteLine("Running example of Change Of Responsability"); ChainOfResponsability chain = new ChainOfResponsability(); chain.Run(); break; case 2: ConsoleUtility.WriteLine("Running example of Command"); CommandTest command = new CommandTest(); command.Run(); break; case 3: ConsoleUtility.WriteLine("Running example of Observer"); ObserverTest observer = new ObserverTest(); observer.Run(); break; case 4: ConsoleUtility.WriteLine("Running example of Iterator"); IteratorTest iterator = new IteratorTest(); iterator.Run(); break; case 5: ConsoleUtility.WriteLine("Running example of State"); StateTest state = new StateTest(); state.Run(); break; case 6: ConsoleUtility.WriteLine("Running example of Template Method"); TemplateMehodTest templateMehod = new TemplateMehodTest(); templateMehod.Run(); break; case 7: ConsoleUtility.WriteLine("Running example of Visitor"); VisitorTest visitor = new VisitorTest(); visitor.Run(); break; case 8: ConsoleUtility.WriteLine("Running example of stratgegy"); StrategyTest strategy = new StrategyTest(); strategy.Run(); break; case 9: ConsoleUtility.WriteLine("Running example of Mediator"); MediatorTest mediator = new MediatorTest(); mediator.Run(); break; case 10: ConsoleUtility.WriteLine("Running example of Memento"); MementoTest memento = new MementoTest(); memento.Run(); break; case 11: ConsoleUtility.WriteLine("Running example of Interpreter"); InterpreterTest interpreter = new InterpreterTest(); interpreter.Run(); break; default: break; } break; case 4: ConsoleUtility.WriteLine("Example of SOLID Principles"); ConsoleUtility.WriteLine("1.-Single Responsibility Principle"); ConsoleUtility.WriteLine("2.-Open-Closed Principle"); ConsoleUtility.WriteLine("3.-Liskov Substitution Principle"); ConsoleUtility.WriteLine("4.-Interface Segregation Principle"); ConsoleUtility.WriteLine("5.-Dependency Inversion Principle"); ii_option = Convert.ToInt32(Console.ReadLine()); switch (ii_option) { case 1: ConsoleUtility.WriteLine("Running example of Single Responsibility"); Invoice invoice = new Invoice(); invoice.Run(); break; case 2: ConsoleUtility.WriteLine("Running example of Open-Closed Principle"); InvoiceOCP invoiceOCP = new InvoiceOCP(); invoiceOCP.Run(); break; case 3: ConsoleUtility.WriteLine("Running example of Liskov Principle"); RunFruit run = new RunFruit(); run.Run(); break; case 4: ConsoleUtility.WriteLine("Running example of Interface Segregation Principle"); Printer printer = new Printer(); printer.Run(); break; case 5: ConsoleUtility.WriteLine("Running example of Dependency Inversion Principle"); RunDIP runDIP = new RunDIP(); runDIP.Run(); break; } break; default: break; } break; case 4: ConsoleUtility.WriteLine("Language DotNet"); ConsoleUtility.WriteLine("1.-Abstract"); ConsoleUtility.WriteLine("2.-Action"); ConsoleUtility.WriteLine("3.-AsyncAwait"); ConsoleUtility.WriteLine("4.-Delegate"); ConsoleUtility.WriteLine("5.-Extensions"); ConsoleUtility.WriteLine("6.-Func"); ConsoleUtility.WriteLine("7.-Generics"); ConsoleUtility.WriteLine("8.-Predicate"); ConsoleUtility.WriteLine("9.-Lock"); ConsoleUtility.WriteLine("10.-Reflection"); ConsoleUtility.WriteLine("11.-IOC Implementation"); ConsoleUtility.WriteLine("12.-Task"); ConsoleUtility.WriteLine("13.-Out Variable"); ConsoleUtility.WriteLine("14.-Pattern Matching"); ConsoleUtility.WriteLine("15.-Digit Separator"); ConsoleUtility.WriteLine("16.-Tuples"); ConsoleUtility.WriteLine("17.-Ref locals and ref return"); ConsoleUtility.WriteLine("18.-AsynReturn"); i_option = Convert.ToInt32(Console.ReadLine()); switch (i_option) { case 1: ConsoleUtility.WriteLine("Running example of Abstract Class"); Square square = new Square(); square.Run(); break; case 2: ConsoleUtility.WriteLine("Running example of Action"); LanguageDotNet.Action action = new LanguageDotNet.Action(); action.Run(); break; case 3: ConsoleUtility.WriteLine("Running example of AsyncAwait"); AsyncAwait asyncAwait = new AsyncAwait(); asyncAwait.Run(); break; case 4: ConsoleUtility.WriteLine("Running example of Delegate"); Number number = new Number(); number.Run(); break; case 5: ConsoleUtility.WriteLine("Running example of Extensions"); IntExtensions intExtensions = new IntExtensions(); intExtensions.Run(); break; case 6: ConsoleUtility.WriteLine("Running example of Func"); Func func = new Func(); func.Run(); break; case 7: ConsoleUtility.WriteLine("Running example of Generics"); Generic generic = new Generic(); generic.Run(); break; case 8: ConsoleUtility.WriteLine("Running example of Predicate"); Predicate predicate = new Predicate(); predicate.Run(); break; case 9: ConsoleUtility.WriteLine("Running example of Lock"); LockTest lockTest = new LockTest(); lockTest.runTest(); break; case 10: ConsoleUtility.WriteLine("Running example of Reflection"); Customer customer = new Customer(); customer.Run(); break; case 11: ConsoleUtility.WriteLine("Running example of IOC Implementation"); IOCImplementation.Run(); break; case 12: ConsoleUtility.WriteLine("Running example of Tasks"); TaskReturnValue taskReturnValue = new TaskReturnValue(); taskReturnValue.Run(); break; case 13: ConsoleUtility.WriteLine("Running example of Out variable"); OutVariables outVariables = new OutVariables(); outVariables.Run(); break; case 14: ConsoleUtility.WriteLine("Running example of Pattern Matching"); PatternMatching patternMatching = new PatternMatching(); patternMatching.Run(); break; case 15: ConsoleUtility.WriteLine("Running example of Digit Separators"); DigitSeparator digitSeparator = new DigitSeparator(); digitSeparator.Run(); break; case 16: ConsoleUtility.WriteLine("Running example of Tuple"); Tuples tuples = new Tuples(); tuples.Run(); break; case 17: ConsoleUtility.WriteLine("Running example of Ref locals and ref returns"); RefLocalRefReturn refLocalRefReturn = new RefLocalRefReturn(); refLocalRefReturn.Run(); break; case 18: ConsoleUtility.WriteLine("Running example of AsyncReturn"); AsyncReturn asyncReturn = new AsyncReturn(); asyncReturn.Run(); break; default: break; } break; default: ConsoleUtility.WriteLine("Exit"); break; } } }
public virtual void VisitPatternPlaceholder(AstNode placeholder, PatternMatching.Pattern pattern) { VisitChildren (placeholder); }
public void Invalid_Argument_IsMatched() { Assert.Throws <ArgumentException>(() => PatternMatching.Match(100)); }
public void VisitPatternPlaceholder(AstNode placeholder, PatternMatching.Pattern pattern) { StartNode(placeholder); VisitNodeInPattern(pattern); EndNode(placeholder); }
public void TestOldTypePattern() { Assert.AreEqual(PatternMatching.TypePatternOld(Rectangle), 20); Assert.Throws <ArgumentException>(() => PatternMatching.TypePatternOld(Square)); }