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();
}
