static void Main() { // Print out the value of some enums Console.WriteLine("*** color ***"); Console.WriteLine(" RED = " + example.RED); Console.WriteLine(" BLUE = " + example.BLUE); Console.WriteLine(" GREEN = " + example.GREEN); Console.WriteLine("\n*** Foo::speed ***"); Console.WriteLine(" Foo::IMPULSE = " + Foo.IMPULSE); Console.WriteLine(" Foo::WARP = " + Foo.WARP); Console.WriteLine(" Foo::LUDICROUS = " + Foo.LUDICROUS); Console.WriteLine("\nTesting use of enums with functions\n"); example.enum_test(example.RED, Foo.IMPULSE); example.enum_test(example.BLUE, Foo.WARP); example.enum_test(example.GREEN, Foo.LUDICROUS); example.enum_test(1234,5678); Console.WriteLine( "\nTesting use of enum with class method" ); Foo f = new Foo(); f.enum_test(Foo.IMPULSE); f.enum_test(Foo.WARP); f.enum_test(Foo.LUDICROUS); }
public void TestUncompilableCode() { new ForceCreationOfInterface().Dispose(); new InheritsProtectedVirtualFromSecondaryBase().Dispose(); new InheritanceBuffer().Dispose(); new HasProtectedVirtual().Dispose(); new Proprietor(5).Dispose(); using (var testOverrideFromSecondaryBase = new TestOverrideFromSecondaryBase()) { testOverrideFromSecondaryBase.function(); var ok = false; testOverrideFromSecondaryBase.function(ref ok); var property = testOverrideFromSecondaryBase.property; testOverrideFromSecondaryBase.VirtualMember(); } using (var foo = new Foo()) { var isNoParams = foo.IsNoParams; foo.SetNoParams(); } using (var hasOverride = new HasOverrideOfHasPropertyWithDerivedType()) hasOverride.CauseRenamingError(); using (var qux = new Qux()) { new Bar(qux).Dispose(); } using (ComplexType complexType = TestFlag.Flag1) { } using (var typeMappedWithOperator = new TypeMappedWithOperator()) { int i = typeMappedWithOperator | 5; } }
public void NotEnablingTrackingDoesNotMarkPropsAsDirty() { var foo = new Foo(); var fooAsTracked = (ITrackedEntity)foo; foo.Name = "Bar"; Assert.Empty(fooAsTracked.GetDirtyProperties()); Assert.Throws<ArgumentOutOfRangeException>(() => fooAsTracked.GetOldValue("Name")); }
public static int Main() { try { Foo testStruct = new Foo(); int val = StructTaker_Inline(testStruct); if (val == 3) { return 100; } else { return 101; } } catch (Exception e) { Console.WriteLine(e.Message); return 666; } }
static void Main(string[] args) { Foo foo = new Foo() {Bar = 4}; MyBackgroundMethod(foo); Console.ReadLine(); }
protected override void ShouldThrowAWobbly() { dynamic testDynamicObject = new Foo(); testDynamicObject.Bar = "BarPropertyValue"; DynamicShould .HaveProperty(testDynamicObject, "foo"); }
public void TestSave() { _collection.RemoveAll(); var foo1 = new Foo { Id = new Id { AccountId = 1, Index = 2 }, Name = "foo1" }; _collection.Save(foo1); var foo1Rehydrated = _collection.FindOne(Query.EQ("_id", BsonDocumentWrapper.Create(foo1.Id))); Assert.IsInstanceOf<Foo>(foo1Rehydrated); Assert.IsInstanceOf<Id>(foo1Rehydrated.Id); Assert.AreEqual(1, foo1Rehydrated.Id.AccountId); Assert.AreEqual(2, foo1Rehydrated.Id.Index); Assert.AreEqual("foo1", foo1Rehydrated.Name); var foo2 = new Foo { Id = new IdWithExtraField { AccountId = 3, Index = 4, Extra = 5 }, Name = "foo2" }; _collection.Save(foo2); var foo2Rehydrated = _collection.FindOne(Query.EQ("_id", BsonDocumentWrapper.Create(foo2.Id))); Assert.IsInstanceOf<Foo>(foo2Rehydrated); Assert.IsInstanceOf<IdWithExtraField>(foo2Rehydrated.Id); Assert.AreEqual(3, foo2Rehydrated.Id.AccountId); Assert.AreEqual(4, foo2Rehydrated.Id.Index); Assert.AreEqual(5, ((IdWithExtraField)foo2Rehydrated.Id).Extra); Assert.AreEqual("foo2", foo2Rehydrated.Name); }
static void Main() { int newValue = 100; Foo foo1 = new Foo(); foo1.Bar = newValue; CheckItWorked(newValue, foo1); // We can change a property of Foo in a method newValue = 99; replaceFooProperty(foo1,newValue); CheckItWorked(newValue, foo1); // But we can't replace the object itself - this will fail newValue = 98; replaceFoo(foo1, newValue); CheckItWorked(newValue, foo1); // ...unless we pass the object as an explicit reference using the ref keyword newValue = 97; replaceFoo(ref foo1, newValue); CheckItWorked(newValue, foo1); Console.ReadLine(); }
public static void RetrievingAnObjectFromANestedFile(Foo result) { "Given a config file containing a Foo with a Bar of 'baz'" .f(() => { using (var writer = new StreamWriter("foo.csx")) { writer.WriteLine(@"#r ""ConfigR.Features.dll"""); writer.WriteLine(@"using ConfigR.Features;"); writer.WriteLine(@"Add(""foo"", new Foo { Bar = ""baz"" });"); writer.Flush(); } }) .Teardown(() => File.Delete("foo.csx")); "And another config file which loads the first config file" .f(() => { using (var writer = new StreamWriter("bar.csx")) { writer.WriteLine(@"LoadScriptFile(""foo.csx"");"); writer.Flush(); } }) .Teardown(() => File.Delete("bar.csx")); "When I load the second config file" .f(() => Config.Global.LoadScriptFile("bar.csx")); "And I get the Foo" .f(() => result = Config.Global.Get<Foo>("foo")); "Then the Foo has a Bar of 'baz'" .f(() => result.Bar.Should().Be("baz")); }
public Bar (int a, params int[] b) { Foo = new Foo (a); Array = new Foo[b.Length]; for (int i = 0; i < b.Length; i++) Array[i] = new Foo (b[i]); }
public void Test (Foo foo) { Hello hello = delegate { Hello (3); }; hello (); }
public void TestExpandNavigateLinq() { //var l = new LoggingVisitor(); //l.Visit(target); var bar = new Bar { BarId = 12, BarString = "a" }; var foo = new Foo { FooId = -1, B = bar, Bars = new[] { bar, new Bar { BarId = 3, BarString = "b" } } }; var mapNavEx = MapFoo.MapNavProperty(_navProperties); Console.WriteLine(mapNavEx.ToString()); Func<Foo, FooDto> mapNav = mapNavEx.Compile(); var testMapped = mapNav(foo); Console.WriteLine("Testing single property"); Assert.AreNotEqual(foo, testMapped); Assert.AreEqual(foo.FooId, testMapped.FooId); Assert.IsNotNull(foo.B); Assert.AreNotEqual(foo.B, testMapped.B); Assert.AreEqual(foo.B.BarId, testMapped.B.BarId); Assert.AreEqual(foo.B.BarString, testMapped.B.BarString); Console.WriteLine("Testing collection"); Assert.AreEqual(foo.Bars.Count, testMapped.Bars.Count()); //todo change to count property var fooBarsLast = foo.Bars.Last(); var testBarsLast = testMapped.Bars.Last(); Assert.AreEqual(fooBarsLast.BarId, fooBarsLast.BarId); }
static void Main() { string p = constover.test("test"); if ( p != "test" ) throw new Exception( "test failed!" ); p = constover.test_pconst("test"); if ( p != "test_pconst" ) throw new Exception( "test_pconst failed!" ); Foo f = new Foo(); p = f.test("test"); if ( p != "test" ) throw new Exception( "member-test failed!" ); p = f.test_pconst("test"); if ( p != "test_pconst" ) throw new Exception( "member-test_pconst failed!" ); p = f.test_constm("test"); if ( p != "test_constmethod" ) throw new Exception( "member-test_constm failed!" ); p = f.test_pconstm("test"); if ( p != "test_pconstmethod" ) throw new Exception( "member-test_pconstm failed!" ); }
public void AddAll() { using (ISession s = OpenSession()) { Foo foo1 = new Foo(); s.Save(foo1); Foo foo2 = new Foo(); s.Save(foo2); Foo foo3 = new Foo(); s.Save(foo3); Baz baz = new Baz(); baz.FooSet = new HashedSet(); baz.FooSet.Add(foo1); s.Save(baz); Assert.AreEqual(1, baz.FooSet.Count); IList foos = new ArrayList(); foos.Add(foo2); foos.Add(foo3); baz.FooSet.AddAll(foos); Assert.AreEqual(3, baz.FooSet.Count); s.Flush(); // Clean up foreach (Foo foo in baz.FooSet) { s.Delete(foo); } s.Delete(baz); s.Flush(); } }
public void DeserializeNakedArray() { var arr = new Foo[0]; var model = TypeModel.Create(); Foo[] foo = (Foo[])model.DeepClone(arr); Assert.AreEqual(0, foo.Length); }
public void SecondMasterShouldUpdateRemoteEtagOnFirstMasterWhenNumberOfFilteredDocumentsExceedsTheLimit() { var store1 = CreateStore(); var store2 = CreateStore(); // master - master SetupReplication(store1.DatabaseCommands, store2); SetupReplication(store2.DatabaseCommands, store1); using (var session = store1.OpenSession()) { for (int i = 0; i < ReplicationTask.DestinationDocsLimitForRemoteEtagUpdate - 1; i++) { session.Store(new Foo { Bar = i }); } session.SaveChanges(); } WaitForReplication(store2, "foos/1"); Assert.Equal(Etag.Empty, GetReplicatedEtag(store1, store2)); // store2 didn't update yet the last replicated etag on server1 // put fake system document to trigger replication task execution store2.DatabaseCommands.Put("Raven/FakeSystemDocument", null, new RavenJObject(), new RavenJObject()); using (var session = store1.OpenSession()) { // additional document to exceed ReplicationTask.DestinationDocsLimitForRemoteEtagUpdate limit var entity = new Foo { Bar = 999 }; session.Store(entity); session.SaveChanges(); WaitForReplication(store2, session.Advanced.GetDocumentId(entity)); } // put fake system document to trigger replication task execution store2.DatabaseCommands.Put("Raven/FakeSystemDocument", null, new RavenJObject(), new RavenJObject()); Etag replicatedEtag = null; for (int i = 0; i < 1000; i++) { replicatedEtag = GetReplicatedEtag(store1, store2); if(replicatedEtag != Etag.Empty) break; Thread.Sleep(100); } Assert.NotNull(replicatedEtag); Assert.NotEqual(Etag.Empty, replicatedEtag); }
public void Blah2() { var foo = new Foo { Name = "Andrew", Friends = { new Friend{Name = "Matt"}, new SubFriend { Name = "Nick", Age = 28 }, } }; var settings = new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.All, ReferenceLoopHandling = ReferenceLoopHandling.Ignore }; var serializeObject = JsonConvert.SerializeObject(foo, Formatting.Indented, settings); var bytes = Encoding.UTF8.GetBytes(serializeObject); var result = JsonConvert.DeserializeObject<Foo>(Encoding.UTF8.GetString(bytes), new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.Objects }); Assert.That(result.Friends.Count, Is.EqualTo(2)); var nick = result.Friends.Single(x => x.Name == "Nick"); Assert.That(nick, Is.TypeOf<SubFriend>()); var matt = result.Friends.Single(x => x.Name == "Matt"); Assert.That(matt, Is.TypeOf<Friend>()); }
static void RunTest (int expected) { IFoo a = (IFoo) new Bar (); Assert.AreEqual (expected, a.Execute (), "#A1"); Assert.AreEqual (expected, a.Count, "#A2"); Bar b = new Bar (); Assert.AreEqual (expected, b.Execute (), "#B1"); Assert.AreEqual (expected, b.Count, "#B2"); Foo c = new Foo (); Assert.AreEqual (1, c.Execute (), "#C1"); Assert.AreEqual (1, c.Count, "#C2"); Assert.AreEqual (expected, ((IFoo) new Bar ()).Execute (), "#D1"); Assert.AreEqual (expected, ((IFoo) new Bar ()).Count, "#D2"); Assert.AreEqual (1, new Bar ().Execute (), "#E1"); Assert.AreEqual (1, new Bar ().Count, "#E2"); Assert.AreEqual (1, new Foo ().Execute (), "#F1"); Assert.AreEqual (1, new Foo ().Count, "#F2"); Assert.AreEqual (expected, CreateBar ().Execute (), "#G1"); Assert.AreEqual (expected, CreateBar ().Count, "#G2"); }
public static void Main() { Foo f = new Foo(0, 1); Bar b = new Bar(0, 1, new Foo(0, 1)); Test t = new Test(); Date d = new Date("3/9/1976"); int[] items = new Array(); int[] items2 = new int[] { 1, 2 }; int[] items3 = { 4, 5 }; int[] items4 = new int[5]; ArrayList list = new ArrayList(); ArrayList list2 = new ArrayList(5); ArrayList list3 = new ArrayList("abc", "def", "ghi"); ArrayList list4 = new ArrayList(1, 2, 3); Date[] dates = new Date[] { new Date("1/1/2006"), new Date("1/1/2005") }; Point p = new Point(0, 0); CustomDictionary cd = new CustomDictionary(); CustomDictionary cd2 = new CustomDictionary("abc", 123, "def", true); object o1 = Script.CreateInstance(typeof(Test)); Type type1 = typeof(Foo); object o2 = Script.CreateInstance(type1, 1, 2); object o3 = Script.CreateInstance(typeof(Bar), 1, 2, (Foo)o2); Function f1 = new Function("alert('hello');"); Function f2 = new Function("alert(s);", "s"); Function f3 = new Function("alert(greeting + ' ' + name + '!');", "greeting", "name"); }
public void RepeatedAccessYieldsSameObject(Foo foo) { var bar1 = foo.Bar; var bar2 = foo.Bar; bar1.Should().BeSameAs(bar2); }
public Task Go(Foo foo) { return Task.Factory.StartNew(() => { Thread.Sleep(100); AsyncWatcher.Messages.Add("go:" + foo.Name); }); }
public void DoSomething() { var foo = new Foo {A = 3}; var bar = new Bar {B = 3}; Console.WriteLine("Start Values:\nFoo.A: {0} \nBar.B: {1}", foo.A, bar.B); TakeFoo(ref foo); TakeBar(bar); Console.WriteLine("After TakeFoo und TakeBar:\nFoo.A: {0} \nBar.B: {1}", foo.A, bar.B); int i = 3; Console.WriteLine("Start Value:\nint i {0}", i); TakeInt(ref i); Console.WriteLine("After TakeInt : int i: {0} \n", i); string s = "vorher"; Console.WriteLine("Start Value:\nstring s {0}", s); TakeString(ref s); Console.WriteLine("After TakeString : string s: {0} \n", s); int[] array ={0,0,0}; //array[0] = 0; // array[1] = 1; //array[2] = 2; foreach (var i1 in array) { Console.WriteLine("Start Value {0}", array[i1]); } TakeArray(array); foreach (var i2 in array) { Console.WriteLine("End Value {0}", i2); } }
public void can_use_non_existing_function2() { using (var store = NewDocumentStore()) { var foo = new Foo { Name = "test" }; using (var session = store.OpenSession()) { session.Store(foo); session.SaveChanges(); } store.DatabaseCommands.Patch(foo.Id, new ScriptedPatchRequest { Script = @"var test = ['My', 'Array']; this.Name = function() {}" }); using (var session = store.OpenSession()) { var loaded = session.Load<Foo>(foo.Id); Assert.Null(loaded.Name); } } }
public void TestSave() { var server = LegacyTestConfiguration.Server; var database = LegacyTestConfiguration.Database; var collection = LegacyTestConfiguration.GetCollection<Foo>(); var conventions = new ConventionPack(); conventions.Add(new NamedIdMemberConvention(new[] { "FooId" })); ConventionRegistry.Register("test", conventions, t => t == typeof(Foo)); BsonClassMap.RegisterClassMap<Foo>(); collection.RemoveAll(); for (int i = 0; i < 10; i++) { var foo = new Foo { FooId = ObjectId.Empty, Name = string.Format("Foo-{0}", i), Summary = string.Format("Summary for Foo-{0}", i) }; collection.Save(foo); var count = collection.Count(); Assert.AreEqual(i + 1, count); } }
public void can_save_javascript_array_values() { using (var store = NewDocumentStore()) { var foo = new Foo { List = {"test"} }; using (var session = store.OpenSession()) { session.Store(foo); session.SaveChanges(); } store.DatabaseCommands.Patch(foo.Id, new ScriptedPatchRequest { Script = @"var list = ['my', 'list']; for(var x in list){ this.List[x] = list[x]; }" }); using (var session = store.OpenSession()) { var loaded = session.Load<Foo>(foo.Id); Assert.Equal(new List<string> {"my", "list"}, loaded.List); } } }
public void ReadOnly() { Foo foo = new Foo(); //note an instance is need for a readonly foo.message.ShouldBe(_); }
public void TestFixtureSetUp() { configuration = new Configuration(); configuration.SessionFactory() .Integrate.Using<SQLiteDialect>() .Connected.Using("Data source=testdb") .AutoQuoteKeywords() .LogSqlInConsole() .EnableLogFormattedSql(); var mapper = new ConventionModelMapper(); mapper.Class<Foo>(cm => { }); mapper.Class<Bar>(cm => { }); CustomizeMapping(mapper); var mappingDocument = mapper.CompileMappingForAllExplicitlyAddedEntities(); new XmlSerializer(typeof(HbmMapping)).Serialize(Console.Out, mappingDocument); configuration.AddDeserializedMapping(mappingDocument, "Mappings"); new SchemaExport(configuration).Create(true, true); sessionFactory = configuration.BuildSessionFactory(); using (var session = sessionFactory.OpenSession()) using (var tx = session.BeginTransaction()) { var foo = new Foo { Bars = CreateCollection() }; foo.Bars.Add(new Bar { Data = 1 }); foo.Bars.Add(new Bar { Data = 2 }); id = session.Save(foo); tx.Commit(); } sessionFactory.Statistics.IsStatisticsEnabled = true; }
static void Main() { // Print out the value of some enums Console.WriteLine("*** color ***"); Console.WriteLine(" " + color.RED + " = " + (int)color.RED); Console.WriteLine(" " + color.BLUE + " = " + (int)color.BLUE); Console.WriteLine(" " + color.GREEN + " = " + (int)color.GREEN); Console.WriteLine("\n*** Foo::speed ***"); Console.WriteLine(" Foo::" + Foo.speed.IMPULSE + " = " + (int)Foo.speed.IMPULSE); Console.WriteLine(" Foo::" + Foo.speed.WARP + " = " + (int)Foo.speed.WARP); Console.WriteLine(" Foo::" + Foo.speed.LUDICROUS + " = " + (int)Foo.speed.LUDICROUS); Console.WriteLine("\nTesting use of enums with functions\n"); example.enum_test(color.RED, Foo.speed.IMPULSE); example.enum_test(color.BLUE, Foo.speed.WARP); example.enum_test(color.GREEN, Foo.speed.LUDICROUS); Console.WriteLine( "\nTesting use of enum with class method" ); Foo f = new Foo(); f.enum_test(Foo.speed.IMPULSE); f.enum_test(Foo.speed.WARP); f.enum_test(Foo.speed.LUDICROUS); }
static int Main () { Foo foo = new Foo (); foo.Test = "BAR"; foo.NullableInt = 10; XmlSerializer serializer = new XmlSerializer (typeof (Foo)); MemoryStream stream = new MemoryStream (); serializer.Serialize (stream, foo); stream.Position = 0; foo = (Foo) serializer.Deserialize (stream); if (foo.Test != "BAR") return 1; if (foo.NullableInt != 10) return 2; foo.NullableInt = null; stream = new MemoryStream (); serializer.Serialize (stream, foo); stream.Position = 0; foo = (Foo) serializer.Deserialize (stream); if (foo.Test != "BAR") return 3; if (foo.NullableInt != null) return 4; return 0; }
public void Bug() { Foo parent = new Foo(); parent.Children.Add(new Foo()); parent.Children.Add(new Foo()); using (ISession s = OpenSession()) { s.Save(parent); s.Flush(); } using (ISession s = OpenSession()) { Foo parentReloaded = s.Get<Foo>(parent.Id); parentReloaded.Children.RemoveAt(0); s.Flush(); } using (ISession s = OpenSession()) { s.Delete(s.Get<Foo>(parent.Id)); s.Flush(); } }
public void Put(Foo foo) { _repository.Update(foo); }
public void Test10() { var foo = new Foo(); Assert.NotNull(foo); }
protected override void ShouldPass() { dynamic testDynamicObject = new Foo(); DynamicShould.HaveProperty(testDynamicObject, "Bar"); }
public static void GiveMeFoo(Foo foo) { }
static void Main() { Foo <SomeClass> f = new Foo <SomeClass> (); f.Do("something"); }
public void AddHandle(EventType _type, Foo _fun) { Handles.Add(_type, _fun); }
public void Delete(Foo foo) { _repository.Delete(foo); }
public Top(Foo foo, IUnityContainer container) { some = CreateSome(localRuntimeVariable); Child = container.Resolve <Child>(new ParameterOverride("some" some), new ParameterOverride("Foo", foo)); }
public void TestHello() { var hello = new Hello(); hello.PrintHello("Hello world"); Assert.That(hello.Add(1, 1), Is.EqualTo(2)); Assert.That(hello.Add(5, 5), Is.EqualTo(10)); Assert.IsTrue(hello.Test1(3, 3.0f)); Assert.IsFalse(hello.Test1(2, 3.0f)); var foo = new Foo { A = 4, B = 7 }; Assert.That(hello.AddFoo(foo), Is.EqualTo(11)); Assert.That(hello.AddFooPtr(foo), Is.EqualTo(11)); Assert.That(hello.AddFooPtr(foo), Is.EqualTo(11)); Assert.That(hello.AddFooRef(foo), Is.EqualTo(11)); unsafe { var pointer = foo.SomePointer; var pointerPointer = foo.SomePointerPointer; for (int i = 0; i < 4; i++) { Assert.AreEqual(i, pointer[i]); Assert.AreEqual(i, (*pointerPointer)[i]); } } var bar = new Bar { A = 4, B = 7 }; Assert.That(hello.AddBar(bar), Is.EqualTo(11)); Assert.That(bar.RetItem1(), Is.EqualTo(Bar.Item.Item1)); var retFoo = hello.RetFoo(7, 2.0f); Assert.That(retFoo.A, Is.EqualTo(7)); Assert.That(retFoo.B, Is.EqualTo(2.0)); var foo2 = new Foo2 { A = 4, B = 2, C = 3 }; Assert.That(hello.AddFoo(foo2), Is.EqualTo(6)); Assert.That(hello.AddFoo2(foo2), Is.EqualTo(9)); var bar2 = new Bar2 { A = 4, B = 7, C = 3 }; Assert.That(hello.AddBar2(bar2), Is.EqualTo(14)); Assert.That(hello.RetEnum(Enum.A), Is.EqualTo(0)); Assert.That(hello.RetEnum(Enum.B), Is.EqualTo(2)); Assert.That(hello.RetEnum(Enum.C), Is.EqualTo(5)); //Assert.That(hello.RetEnum(Enum.D), Is.EqualTo(-2147483648)); Assert.That(hello.RetEnum(Enum.E), Is.EqualTo(1)); Assert.That(hello.RetEnum(Enum.F), Is.EqualTo(-9)); }
public Foo Post(Foo foo) { return(_repository.Insert(foo)); }
public void TestBar() { var foo = new Foo(); Assert.AreEqual(42, foo.Bar()); }
public Child(ISome some, Foo foo) { }
public static int MainMethod() { Foo f = Bar; return(f(2)); }
public void TestANSI() { var foo = new Foo(); Assert.That(foo.ANSI, Is.EqualTo("ANSI")); }
public Baz(Foo foo) { this.Foo = foo; }
public static int MainMethod() { Foo f = Foo2; return(f()); }
public static void Test3(Foo @this, int ix) { @this.Test123(123, 456); }
public void SetFoo(Foo f) { foo = f; }
public void Compare(Foo <int> a) { }
public TOutput ConvertAll <TOutput> (Foo <T, TOutput> arg) { return(default(TOutput)); }
public FooProxy(Foo wrapped) { this.wrapped = wrapped; }
public void NullArg() { Foo foo = new Foo(); foo.Send(null); }
public virtual void event_handler <T> (Foo <T> sender) { the_type = typeof(T); }
public override string X() { return(Foo.X()); }
public static void MethodWithUnboundOutParameterAndNoJobAttribute(string input, out Foo parsed) { throw new NotImplementedException(); }
public void SomeActionMethod(Foo someParams) { var utility = new CustomerOrderBuilderUtility(_customerRepo, _orderRepo); var customerWithOrders = utility.GetCustomerAndOrders(someParams.CustomerId); // some domain logic... }
// This constructs an Example`1 with the Foo constructor. public static Example <A> Create(Foo term) { return(new Example <A>(Tag.Foo, term)); }
protected override Foo Clone(Foo foo) => (Foo) new Foo().InjectFrom <CloneInjection>(foo);
static void UsedToMarkMethod(Foo f) { IFoo i = f; i.Method(); }
public static void FailIndexing(string input, out Foo parsed) { throw new NotImplementedException(); }