KEYWORD sequential

[srburton]

KEYWORD sequential

Model People

public class People
{
    public string Name {get; set;}
    public string LastName {get; set;}
    public string State {get; set;}
    public string City {get; set;}
}

Validator methods

public class Validator
{
     public static void NotEmpty<T>(T param, string error){  ...  }
     public static void MaxCaracter<T>(T param, string error,int max){  ...  }
     public static void CheckSocialSegure<T>(T socialNumber, T state, T city, string error) { ... }
}

---

Keyword use case

Object

var people = new People();
sequential people in p 
{
   Validator.NotEmpty(p.Name,"Not Empty!");
   Validator.MaxCaracter(p,Name,"Max caracter is 8",8);
}

List

var peoples = new List<People>()
{
    new People()
};
var socialNumber = 232324;

sequential peoples in p
{
   Validator.NotEmpty(p.Name,"Not Empty!");
   Validator.CheckSocialSegure(socialNumber, p.State, p.City, "Not is social segure!" );
}

Primitive[]

var myStrings = new string[] { "Hello", "C#"};

sequential myString in m
{
   Console.Write(m);
}

//Output sequential 
Hello
c#

Primitive

string myString =  "Hello";

sequential myString in m
{
   Console.Write(m);
}

//Output sequential 
H
e
l
l
o

string myInt =  092873;

sequential myInt  in m
{
  Console.Write(m);
}

//Output sequential 
0
9
2
8
7
3
 

dynamic

       var myDynamic = new
            {
                Name = "",
                LastName = "",
                Address = new
                {
                    City = ""
                }
            };
            

sequential myDynamic in m
{
   Validator.NotEmpty(m.Name,"Not Empty!");
   
   sequential m.Address in a
    {
             Validator.NotEmpty(a.City,"Not Empty city!");
             //Example "NameAndCity"
             //Validator.NameAndCity(m.Name,a.City,"City is valid!");
    }

}

In this example I want to demonstrate that a method if called within the sequential it does not run on how much it does not reach its turn, this scenario would be for validations and testing in methods a native form of summarizing code and grouping a particular operation.

[HaloFour]

Most of this looks like a normal foreach loop. The rest looks like some weird variant of a with keyword. The fact that it seemingly does double duty is bad enough, but I don't see anything here that can't already be accomplished with existing syntax that isn't any more verbose.

Can you write examples as to how you'd accomplish this without new syntax?

[srburton]

@HaloFour
This keyword it does not differ much from the foreach, its differential that it makes anything in an array and scrolls item by item

[srburton]

The keyword sequence makes everything in an array or list and traverses item by item so it can traverse any type.

[yaakov-h]

How is that any different to foreach?

[Unknown6656]

You can solve this using conventional foreach loops:

var people = new People[] { ... };
// or
var people = new List<People>();   


foreach (var p in people)
    try
    {
        Validator.NotEmpty(p.Name, "Not Empty!");
        Validator.MaxCaracter(p,Name, "Max caracter is 8", 8);
    }
    catch (Exception ex)
    {
        Console.WriteLine($"'{p}' could not be validated: {ex.Message}");

        return;
    }

Why would we need a new keyword?
The LDT does not like new keywords (and neither does most of the community), as they:

• could clash with existing code
• could prevent the usage of that word in the future
• they are often redundant
• they do not "fit" to well with C# language outside of declarative constructs. (VisualBasic would be happier with more keywords 😉 )

So I would like to ask you, why do we need sequential ... in ... instead of foreach ... in ...?
What is the behaviour concerning thread safety, exceptions, etc.? Which precise syntax do you want?