delegate int Incrementor(int number);//3.5
private void materialRaisedButton1_Click(object sender, EventArgs e)
{
Order order = new Order();
order.Name = materialSingleLineTextField4.Text;
order.Surname = materialSingleLineTextField5.Text;
order.PhoneNumber = materialSingleLineTextField6.Text;
order.Email = materialSingleLineTextField7.Text;
order.CardNumber = materialSingleLineTextField1.Text;
order.CardExpireDate = materialSingleLineTextField3.Text;
order.CVV = Convert.ToInt32(materialSingleLineTextField2.Text);
Admin admin = new Admin();
admin.ConfirmOrder(order);
Incrementor func = delegate(int number)
{
number++;
return(number);
};
func(admin.number);
Form4 f4 = new Form4();
this.Hide();
f4.Show();
this.Close();
}
private void Awake()
{
Instance = GameObject.Find("Incrementor").GetComponent <Incrementor>();
grandmaButton = GameObject.Find("Button_Grandma").GetComponent <Button>();
m_soundScript = GameObject.Find("Sound").GetComponent <SoundScript>();
}
/// <param name="checker">Convergence checker.</param>
/// <param name="maxEval">Maximum number of objective function evaluations.</param>
/// <param name="maxIter">Maximum number of algorithm iterations.</param>
protected BaseOptimizer(ConvergenceChecker <T> checker, int maxEval, int maxIter)
{
this.checker = checker;
evaluations = new Incrementor(maxEval, (e) => { throw new Exception(e.ToString()); });
iterations = new Incrementor(maxIter, (e) => { throw new Exception(e.ToString()); });
}
public override void Compile(EmitCompilerContext context, EmitIl il)
{
Initializer?.Compile(context, il);
var start = il.DefineLabel();
var end = il.DefineLabel();
il.MarkLabel(start);
if (Predicate != null)
{
Predicate.Compile(context, il);
}
else
{
il.Emit(EmitOpCodes.Ldc_I4_1);
}
il.Emit(EmitOpCodes.Brfalse, end);
Body.Compile(context, il);
Incrementor?.Compile(context, il);
il.Emit(EmitOpCodes.Br, start);
il.MarkLabel(end);
}
public void Run()
{
var myGenericIntDelegate = new Incrementor <int>(IntIncrementor);
var myGenericStrDelegate = new Incrementor <string>(StringIncrementor);
var myGenericDelegate = new Incrementor <long>(GenericIncrementor);
myGenericIntDelegate.Invoke(1);
myGenericStrDelegate.Invoke(1.ToString());
myGenericDelegate.Invoke(1);
var mySuperTypedDelegate = new SuperIncrementor <string>(SuperStringIncrementor);
mySuperTypedDelegate.Invoke("22");
Action <string> stringIncrementorAction = StringIncrementor;
stringIncrementorAction("10");
Func <string, string> genericLongFunc = SuperStringIncrementor;
genericLongFunc("generic");
Predicate <int> valueCheckerPredicate = i => i < 10;
Console.WriteLine(valueCheckerPredicate.Invoke(10));
valueCheckerPredicate += i => i % 2 == 0;
Console.WriteLine(valueCheckerPredicate.Invoke(10));
}
internal static IEnumerable <Range <T> > NormalizeFromSorted <T>(this IEnumerable <Range <T> > that) // Items MUST be sorted by `From` property
where T : IComparable <T>
{
using (var enumerator = that.GetEnumerator()) {
if (enumerator.MoveNext())
{
var range = enumerator.Current;
var from = range.From;
var to = range.To;
while ((to.CompareTo(Incrementor <T> .MaxValue) < 0) && enumerator.MoveNext())
{
range = enumerator.Current;
if (range.From.CompareTo(Incrementor <T> .Increment(to)) > 0)
{
yield return(new Range <T>(@from, to));
@from = range.From;
to = range.To;
}
else if (range.To.CompareTo(to) > 0)
{
to = range.To;
}
}
yield return(new Range <T>(@from, to));
}
}
}
private static void Check(Incrementor inc, ref long rollingKey, byte nb, long mask)
{
if (nb == 255)
{
return;
}
rollingKey = ((rollingKey & mask) << 2) | nb;
inc.Increment(rollingKey);
}
public Parameters(string alias, string connective, Incrementor queryParamCounter)
{
this.alias = alias;
this.connective = connective;
this.queryParamCounter = queryParamCounter;
subParameters = new List <Parameters>();
negatedParameters = new List <Parameters>();
expressions = new List <string>();
localQueryParamValues = new Dictionary <string, object>();
}
//only for clone purpose
private QueryBuilder(QueryBuilder other)
{
_entityName = other._entityName;
RootAlias = other.RootAlias;
_aliasCounter = (Incrementor)other._aliasCounter.Clone();
_paramCounter = (Incrementor)other._paramCounter.Clone();
RootParameters = (Parameters)other.RootParameters.Clone();
_froms = new List <Tuple <string, string> >(other._froms);
_orders = new List <Tuple <string, bool> >(other._orders);
_projections = new List <string>(other._projections);
}
public Parameters(string alias, string connective, Incrementor queryParamCounter)
{
this.alias = alias;
this.connective = connective;
this.queryParamCounter = queryParamCounter;
subParameters = new List<Parameters>();
negatedParameters = new List<Parameters>();
expressions = new List<string>();
localQueryParamValues = new Dictionary<string, object>();
}
virtual public void AppTimer_Tick(object sender, EventArgs e)
{
Incrementor.IncrementY();
// none of the widgets implement this guy.
foreach (var widget in Widgets)
{
widget.Increment();
}
// draw
Invalidate();
}
internal override void Bind(Binder binder)
{
binder.Bookmark();
Initializer?.Bind(binder);
Condition?.Bind(binder);
Body.Bind(binder);
Incrementor?.Bind(binder);
binder.Checkout();
}
public void TestToString()
{
var inc = new Incrementor(0, 10);
inc.ToString().Should().Be("0");
for (int i = 1; i <= 10; i++)
{
inc = inc.IncrementValue();
inc.ToString().Should().Be(i.ToString());
}
}
public void TestIncrementBy2()
{
var inc = new Incrementor(10, 20, 2);
inc.Value.Should().Be(10);
for (int i = 1; i <= 5; i++)
{
inc = inc.IncrementValue();
inc.Value.Should().Be(10 + 2 * i);
}
}
public void TestIncrementBy1()
{
var inc = new Incrementor(0, 10);
inc.Value.Should().Be(0);
for (int i = 1; i <= 10; i++)
{
inc = inc.IncrementValue();
inc.Value.Should().Be(i);
}
}
public void TestNoParentIncrementor()
{
var inc1 = new Incrementor(0, 3);
inc1.CanIncrement.Should().BeTrue();
var maxInc = inc1.IncrementValue().IncrementValue().IncrementValue();
maxInc.CanIncrement.Should().BeFalse();
Action act = () => maxInc.IncrementValue();
act.ShouldThrow <InvalidOperationException>();
}
private static bool IsAdjacent(IReadOnlyList <KeyValuePair <Range <TLetter>, LetterId> > ranges, int left, int right)
{
Debug.Assert((Math.Max(left, right) >= 0) && (Math.Min(left, right) < ranges.Count) && ((left + 1) == right));
if (left < 0)
{
return(ranges[right].Key.From.Equals(Incrementor <TLetter> .MinValue));
}
if (right >= ranges.Count)
{
return(ranges[left].Key.To.Equals(Incrementor <TLetter> .MaxValue));
}
return(Incrementor <TLetter> .Increment(ranges[left].Key.To).Equals(ranges[right].Key.From));
}
delegate int Incrementor(int number);//3.5
public void Withdraw(int sum)
{
Incrementor func = delegate(int number) //3.5 анонімна
{
number++;
return(number);
};
if (_sum >= sum)
{
_sum -= sum;
}
}
static void Main(string[] args)
{
Incrementor incr = new Incrementor();
Decrementor decr = new Decrementor();
Thread t1 = new Thread(incr.inc);
Thread t2 = new Thread(decr.dec);
t1.Start();
t2.Start();
t1.Join();
t2.Join();
Console.ReadKey();
}
private QueryBuilder(string entityName, string alias, Incrementor aliasCounter, Incrementor paramCounter)
{
_entityName = entityName;
RootAlias = alias;
_aliasCounter = aliasCounter;
_paramCounter = paramCounter;
_parameters.Add(new Parameters(alias, "and", paramCounter));
_froms = new List <Tuple <string, string, bool> >();
_orders = new List <Tuple <string, string, bool> >();
_projections = new List <string>();
AddFrom(entityName, alias, true);
}
public int Count()
{
if (typeof(IConvertible).IsAssignableFrom(typeof(T)))
{
return((int)(((IConvertible)this.To).ToInt64(CultureInfo.InvariantCulture) - ((IConvertible)this.From).ToInt64(CultureInfo.InvariantCulture)) + 1);
}
var result = 1;
var current = this.From;
while (current.CompareTo(this.To) < 0)
{
result++;
current = Incrementor <T> .Increment(current);
}
return(result);
}
/// <summary>
/// Obtains an Incrementor from the database. If one does not exists and the <param name="addUserIfNotExists"/> is true, we create the Incrementor.
/// </summary>
/// <param name="userId">The user to obtain the incrementor for.</param>
/// <param name="addUserIfNotExists">Whether or not to create the user if needed.</param>
/// <returns>The Incrementor for the user, or a newly created one if requested. Null otherwise.</returns>
public Incrementor GetIncrementor(string userId, bool addUserIfNotExists = false)
{
Incrementor result = Db.Incrementors.Where(inc => inc.UserId == userId).FirstOrDefault();
if (result == null && addUserIfNotExists)
{
result = new Incrementor()
{
UserId = userId,
Value = 0
};
Db.Incrementors.Add(result);
}
return(result);
}
public Incrementor SetIncrementorValue(string userId, ulong value, bool addUserIfNotExists = false)
{
Incrementor incrementor = GetIncrementor(userId, addUserIfNotExists);
if (incrementor != null)
{
incrementor.Value = value;
if (Db.Entry(incrementor).State == Microsoft.EntityFrameworkCore.EntityState.Unchanged)
{
Db.Entry(incrementor).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
}
}
return(incrementor);
}
public static Operator GetInstance(string symbol)
{
Operator ret = null;
switch (symbol)
{
case "inc":
ret = new Incrementor();
break;
case "dec":
ret = new Decrementor();
break;
}
return(ret);
}
public void TestCombined()
{
var inc1 = new Incrementor(0, 3);
var inc2 = new Incrementor(5, 7);
var combined = Incrementor.CreateCombined(new Incrementor[] { inc1, inc2 });
string[] expected = { "05", "06", "07", "15", "16", "17", "25", "26", "27", "35", "36", "37" };
for (int i = 0; i < expected.Length; i++)
{
combined.ToString().Should().Be(expected[i]);
if (combined.CanIncrement)
{
combined = combined.IncrementValue();
}
}
}
//only for clone purpose
private Parameters(Parameters other)
{
alias = other.alias;
connective = other.connective;
queryParamCounter = (Incrementor)other.queryParamCounter.Clone();
subParameters = new List <Parameters>(other.subParameters.Count);
foreach (var p in other.subParameters)
{
subParameters.Add((Parameters)p.Clone());
}
negatedParameters = new List <Parameters>(other.negatedParameters.Count);
foreach (var p in other.negatedParameters)
{
negatedParameters.Add((Parameters)p.Clone());
}
expressions = new List <string>(other.expressions);
localQueryParamValues = new Dictionary <string, object>(other.localQueryParamValues);
}
public IEnumerable <KeyValuePair <Range <TKey>, TValue> > Slice(Range <TKey> range)
{
switch (this.items.Count)
{
case 0:
break;
case 1:
var single = this.items[0];
var singleFrom = Incrementor <TKey> .Max(single.Key.From, range.From);
var singleTo = Incrementor <TKey> .Min(single.Key.To, range.To);
if (singleFrom.CompareTo(singleTo) <= 0)
{
yield return(new KeyValuePair <Range <TKey>, TValue>(new Range <TKey>(singleFrom, singleTo), single.Value));
}
break;
default:
var left = RangeOperations <TKey> .BinarySearch(this.Keys, range.From);
if (left < 0)
{
left = ~left;
}
var right = RangeOperations <TKey> .BinarySearch(this.Keys, range.From);
if (right < 0)
{
right = ~right - 1;
}
for (var i = left; i <= right; i++)
{
var current = this.items[i];
var from = current.Key.From;
var to = current.Key.To;
yield return(new KeyValuePair <Range <TKey>, TValue>(
new Range <TKey>((i == left) && (@from.CompareTo(range.From) < 0) ? range.From : from, (i == right) && (to.CompareTo(range.To) > 0) ? range.To : to),
current.Value));
}
break;
}
}
private void MergeIfAdjacent(int left, int right)
{
Debug.Assert((right - left) == 1);
if ((left < 0) || (right >= this.items.Count))
{
return;
}
var leftItem = this.items[left];
var rightItem = this.items[right];
if (!this.valueEqualityComparer.Equals(leftItem.Value, rightItem.Value))
{
return;
}
if (Incrementor <TKey> .Adjacent(leftItem.Key.To, rightItem.Key.From))
{
this.items.RemoveAt(right);
this.items[left] = new KeyValuePair <Range <TKey>, TValue>(new Range <TKey>(leftItem.Key.From, rightItem.Key.To), leftItem.Value);
}
}
internal override IEnumerable <NameExpression> Walk()
{
List <NameExpression> freeVars = new List <NameExpression>();
freeVars.AddRange(Initializer?.Walk() ?? new NameExpression[0]);
freeVars.AddRange(Condition?.Walk() ?? new NameExpression[0]);
freeVars.AddRange(Incrementor?.Walk() ?? new NameExpression[0]);
freeVars.AddRange(Body.Walk());
if (Initializer is Definition definition)
{
List <Variable> initializerVariable = new List <Variable>
{
definition.DeclaredVariable
};
Compiler.MatchVariables(freeVars, initializerVariable);
}
return(freeVars);
}
internal override IEnumerable <Instruction> Compile()
{
List <Instruction> instructions = new List <Instruction>();
instructions.AddRange(Initializer?.Compile() ?? new Instruction[0]);
List <Instruction> bodyInstructions = Body.Compile().ToList();
bodyInstructions.AddRange(Incrementor?.Compile() ?? new Instruction[0]);
List <Instruction> check;
if (Condition == null)
{
// No condition? We're in a forever loop
check = new List <Instruction>();
}
else
{
check = Condition.Compile().ToList();
check.AddRange(
Compiler.CompileImplicitConversion(
Condition.GetKnownType(),
RedwoodType.GetForCSharpType(typeof(bool))
)
);
check.Add(new ConditionalJumpInstruction(2));
// Next instruction (1) + Body + Increment + Jump instruction (1)
check.Add(new JumpInstruction(bodyInstructions.Count + 2));
}
// Jump back to the beginning of the loop
bodyInstructions.Add(new JumpInstruction(-(bodyInstructions.Count + check.Count)));
instructions.AddRange(check);
instructions.AddRange(bodyInstructions);
return(instructions);
}
private static UsedRangeList <TLetter> MakeRanges(IDictionary <Id <RxMatch <TLetter> >, KeyValuePair <RangeSet <TLetter>, ICollection <LetterId> > > charsets, RangeSet <TLetter> validRanges)
{
var ranges = new UsedRangeList <TLetter>();
foreach (var validRange in validRanges)
{
ranges.Add(new UsedLetterRange <TLetter>(validRange, null));
}
foreach (var pair in charsets)
{
foreach (var charRange in pair.Value.Key)
{
// split left if necessary
var left = RangeOperations <TLetter> .BinarySearch(ranges, charRange.From);
var leftRange = ranges[left];
if (leftRange.From.CompareTo(charRange.From) < 0)
{
ranges.Insert(left++, new UsedLetterRange <TLetter>(leftRange.From, Incrementor <TLetter> .Decrement(charRange.From), leftRange.Users));
ranges[left] = new UsedLetterRange <TLetter>(charRange.From, leftRange.To, leftRange.Users);
}
// split right if necessary
var right = RangeOperations <TLetter> .BinarySearch(ranges, charRange.To);
var rightRange = ranges[right];
if (rightRange.To.CompareTo(charRange.To) > 0)
{
ranges[right] = new UsedLetterRange <TLetter>(rightRange.From, charRange.To, rightRange.Users);
ranges.Insert(right + 1, new UsedLetterRange <TLetter>(Incrementor <TLetter> .Increment(charRange.To), rightRange.To, rightRange.Users));
}
// add user information
for (var i = left; i <= right; i++)
{
ranges[i] = ranges[i].AddUser(pair.Key);
}
}
}
return(ranges);
}
