| Transportation Cost | Factory 1 | Factory 2 | Factory 3 |
| Mine 1 | c11 | c12 | c13 |
| Mine 2 | c21 | c22 | c23 |
| Mine 3 | c31 | c32 | c33 |
| Supply\Demand | 150 | 50 | 50 | Allocation sums for mines |
| 40 | 10 | x12 | x13 | 10 |
| 110 | x21 | x22 | x23 | 0 |
| 100 | x31 | x32 | 20 | 20 |
| Allocation sums for factories | 10 | 0 | 20 |
public void UpdateClient(
int id,
string name,
string secondname,
string surname,
string salutation,
int age,
string sex,
string country,
string city,
string province,
string address,
string postalCode,
string phoneNumber,
string faxNumber,
string country2,
string city2,
string province2,
string address2,
string postalCode2,
string phoneNumber2,
string faxNumber2,
...)
{
//...
}
Do you think that this code requires any refactoring? If yes, give your proposition. A database access technology doesn't matter in this question.public void UpdateClient(Client client)
{
//...
}
Where Client is a class that models clients. It can look in the following way:
public class Client
{
public int Id { get; set; }
public string Name { get; set; }
public string Secondname { get; set; }
public string Surname { get; set; }
public string Salutation { get; set; }
public int Age { get; set; }
public string Sex { get; set; }
public Address MainAddress{ get; set; }
public Address AdditionalAdddress { get; set; }
/* More properties */
}
Address class contains details (country, city..) of addresses.
using(var file = File.OpenWrite(path))
{
//...
}
Answer #1
var file = File.OpenWrite(path);
try
{
//...
}
finally
{
if(file != null)
file.Dispose();
}
[Flags]
public enum Crieria : byte
{
None = 0,
CriterionOne = 1,
CriterionTwo = 2,
All = CriterionOne | CriterionTwo
}
We also need a class that will represent patterns.public class Pattern
{
public int FieldOne { get; set; }
public int FieldTwo { get; set; }
}
Now we can write a code that will dynamically build needed expressions. I assumed that every criterion has a corresponding static method that knows how to check if a current pattern fulfils it or not. The final expression produced by CreateExpression method will be of the following form pattern => predicate1(pattern) && predicate2(pattern) && predicate3(pattern)....
public static class FilterBuilder
{
public static Func<Pattern, bool> CreateExpression(Crieria filteringMode)
{
var param = Expression.Parameter(typeof(Pattern));
var subExpressions = new List<MethodCallExpression>();
if ((filteringMode & Crieria.CriterionOne) != 0)
subExpressions.Add(Expression.Call(typeof(FilterBuilder), nameof(CriterionOnePredicate), null, param));
if ((filteringMode & Crieria.CriterionTwo) != 0)
subExpressions.Add(Expression.Call(typeof(FilterBuilder), nameof(CriterionTwoPredicate), null, param));
//Other criteria...
if (subExpressions.Count == 0)
return p => true;
Expression finalExpression = subExpressions[0];
for (var i = 1; i < subExpressions.Count; ++i)
finalExpression = Expression.And(finalExpression, subExpressions[i]);
return Expression.Lambda<Func<Pattern, bool>>(finalExpression, param).Compile();
}
public static bool CriterionOnePredicate(Pattern p)
{
return p.FieldOne > 0;
}
public static bool CriterionTwoPredicate(Pattern p)
{
return p.FieldTwo < 0;
}
}
The code can be made even more generic but I'll leave it as an exercise. When I finished this code I started to worry about performance. It is critical for me because my application needs to process large amount of patterns efficiently. I made the following simple test in which dynamically generated and static functions are executed 1 million times.
var iterations = 1000000;
var predicate = FilterBuilder.CreateExpression(Crieria.All);
MeasureIt<Pattern>((p) => predicate(p), new Pattern(), iterations);
predicate = FilterBuilder.CreateExpression(Crieria.CriterionOne);
MeasureIt<Pattern>((p) => predicate(p), new Pattern(), iterations);
MeasureIt<Pattern>((p) =>
{
FilterBuilder.CriterionOnePredicate(p);
FilterBuilder.CriterionTwoPredicate(p);
}, new Pattern(), iterations );
MeasureIt<Pattern>((p) => FilterBuilder.CriterionOnePredicate(p), new Pattern(), iterations);
In order to measure time of calculations I used MeasureIt method from my earlier post and I received the following results:
Total time: 54 Total time: 27 Total time: 18 Total time: 12Dynamically generated predicates are 2-3 times slower than static ones. However, we are still talking here about dozens of milliseconds in order to make 1 million calls. For me it is acceptable.
CREATE INDEX IX_Test ON dbo.Table(Col_1, Col_2) INCLUDE (Col_4);A istniejący indeks wyglądał tak:
CREATE INDEX IX_Test ON dbo.Table(Col_1, Col_2, Col_3);Wystarczyło, wieć go zmodyfikować w następujący sposób:
CREATE INDEX IX_Test ON dbo.Table(Col_1, Col_2, Col_3) INCLUDE (Col_4);Na koniec sprawdziłem jak taka modyfikacja wpływa na operacje wstawiania/aktualizacji danych do/w docelowej tabeli. W tym celu napisałem zapytania wstawiające setki tysięcy rekordów do tej tabeli, a także takie, które modyfikuje kolumnę Col_4.. Wyniki pokazały niewielkie spadek wydajności. Był on znacznie mniejszy niż zysk przy odczycie danych, a po drugie wiedziałem, że w praktyce omawiana tabela jest częściej czytana niż modyfikowana.
for (int i = 0; i < array.Length; i++) ...A może raczej tak, czyli zapamiętać długości tablicy w zmiennej pomocniczej i nie odczytywać jej przy każdym przebiegu pętli:
for (int i = 0, len = array.Length; i < len; i++) ...Z ciekawości sprawdziłem czy taka mikro optymalizacja ma jakiekolwiek znaczenie w przypadku programowania na platformę .NET. Do zmierzenia czasu użyłem takiej metody pomocniczej:
public static void MeasureIt<T>(Action<T> action, T arg, int noOfIterations)
{
var sw = new Stopwatch();
sw.Start();
for (var i = 0; i < noOfIterations; ++i)
action(arg);
sw.Stop();
Console.WriteLine("Total time: " + sw.ElapsedMilliseconds);
}
Następnie wykonałem następujący test:
var noOfIterations = 100000;
var noOfElements = 10000;
var array = Enumerable.Repeat(1, noOfElements).ToArray();
//Przypadek 1
MeasureIt(arg =>
{
var total = 0;
for (var i = 0; i < arg.Length; i++)
total += a[i];
}, array, noOfIterations);
//Przypadek 2
MeasureIt(arg =>
{
var total = 0;
for (int i = 0, len = arg.Length; i < len; i++)
total += a[i];
}, array, noOfIterations);
Dla rzetelności testy uruchomiłem wielokrotnie. Czas wykonywania obliczeń w obu przypadkach wynosił około 320ms z dokładnością do kilku milisekund. Czasami pierwsze podejście było szybsze, a czasami drugie. Z jednej strony czegoś takiego się spodziewałem. Z drugiej strony sądziłem, że jednak zaobserwuję pewien zysk w drugim przypadku. Dlaczego?
\Tree[.{L0 - Root}
[.{L1 - Left child}
[.{L2 - Left child} ]
[.{L2 - Right child} ]]
[.{L1 - Right child} ]]
Efekt końcowy wygląda natomiast następująco:
public interface ITest
{
int Value { get; set; }
void Start();
}
public class MarshalByRefObjectClass : MarshalByRefObject, ITest
{
public int Value { get; set; }
public void Start()
{
Console.WriteLine(AppDomain.CurrentDomain.FriendlyName);
Value++;
}
}
[Serializable]
public class MarshalByValueClass : ITest
{
public int Value { get; set; }
public void Start()
{
Console.WriteLine(AppDomain.CurrentDomain.FriendlyName);
Value++;
}
}
Mamy również następujący kod, w którym testuję jak zachowuja się:
private static void Test(AppDomain app, ITest test, bool doCallBack)
{
if (doCallBack)
app.DoCallBack(test.Start);
else
test.Start();
Console.WriteLine(test.Value);
}
A to właściwy test, w którym najpierw tworzę obiekty przekazywane przez wartość/referencję lokalnie i w nowej domenie. Następnie wywołuję dla nich metodę Start i odczytuję właściwość Value.
var app = AppDomain.CreateDomain("TestDomain");
var asm = Assembly.GetExecutingAssembly();
var byRef = new MarshalByRefObjectClass();
var byRef1 = new MarshalByRefObjectClass();
var byRef2 = (MarshalByRefObjectClass)app.CreateInstanceFromAndUnwrap(asm.CodeBase, typeof(MarshalByRefObjectClass).FullName);
var byRef3 = (MarshalByRefObjectClass)app.CreateInstanceFromAndUnwrap(asm.CodeBase, typeof(MarshalByRefObjectClass).FullName);
var byValue = new MarshalByValueClass();
var byValue1 = new MarshalByValueClass();
var byValue2 = (MarshalByValueClass)app.CreateInstanceFromAndUnwrap(asm.CodeBase, typeof(MarshalByValueClass).FullName);
var byValue3 = (MarshalByValueClass)app.CreateInstanceFromAndUnwrap(asm.CodeBase, typeof(MarshalByValueClass).FullName);
Test(app, byRef, true);
Test(app, byRef1, false);
Test(app, byRef2, true);
Test(app, byRef3, false);
Test(app, byValue, true);
Test(app, byValue1, false);
Test(app, byValue2, true);
Test(app, byValue3, false);
Pytanie brzmi co zostanie wypisane na ekranie?
Pokaż/Ukryj odpowiedź
Sandbox.vshost.exe 1 Sandbox.vshost.exe 1 TestDomain 1 TestDomain 1 TestDomain 0 Sandbox.vshost.exe 1 TestDomain 0 Sandbox.vshost.exe 1
Windows Registry Editor Version 5.00 [HKEY_CLASSES_ROOT\*\Shell\COMMAND_NAME] [HKEY_CLASSES_ROOT\*\Shell\COMMAND_NAME\command] @="COMMAND"Jeśli polecenie ma być dostępne dla określonych plików
Windows Registry Editor Version 5.00 [HKEY_CLASSES_ROOT\.EXTENSION\Shell\COMMAND_NAME] [HKEY_CLASSES_ROOT\.EXTENSION\Shell\COMMAND_NAME\command] @="COMMAND"Jeśli polecenie ma być dostępne dla katalogów
Windows Registry Editor Version 5.00 [HKEY_CLASSES_ROOT\Directory\Shell\COMMAND_NAME] [HKEY_CLASSES_ROOT\Directory\Shell\COMMAND_NAME\command] @="COMMAND" [HKEY_CLASSES_ROOT\Directory\Background\Shell\COMMAND_NAME] [HKEY_CLASSES_ROOT\Directory\Background\Shell\COMMAND_NAME\command] @="COMMAND"W powyższych wzorcach COMMAND_NAME oznacza nazwę opcji jaka pojawi się w menu kontekstowym np.: Shred, EXTENSION to rozszerzenie pliku np.: txt i w końcu COMMAND to skrypt/polecenie jakie ma zostać wykonane po wybraniu przez użytkownika określonej opcji z menu kontekstowego np.: T:\\bin\\shred -n 10 -v -z \"%1\". Zwróćcie uwagę, że przy podawaniu ścieżki stosuję podwójny ukośnik tj. \\ oraz, że cudzysłów wewnątrz polecenia jest poprzedzony ukośnikiem tj. \". Na koniec uzupełnione wzorce należy zapisać w pliku z rozszerzeniem *.reg i przez podwójne kliknięcie na takim pliku dodać go do rejestru. Zmiany będą widoczne natychmiast.
var s = new LineSeries();
s.Title = "Nieciągłe przedziały";
s.Points.Add(new DataPoint(2, 1));
s.Points.Add(new DataPoint(3, 1));
s.Points.Add(new DataPoint(4, 1));
s.Points.Add(new DataPoint(6, 1));
s.Points.Add(new DataPoint(8, 1));
s.Points.Add(new DataPoint(10, 1));
To jednak nie zadziała gdyż w rezultacie otrzymamy linię ciągłą, czego zresztą należało się spodziewać ponieważ LineSeries po prostu łączy kolejne punkty. Wypróbowałem więc inne rodzaje wykresów, bawiłem się ustawieniami, ale bez rezultatów. Rozwiązanie okazało się jednak bardzo proste. Jeśli nie chcemy, aby dwa punkty zostały połączone linią to pomiędzy nimi należy umieścić punkt o współrzędnych (Double.Nan, Double.NaN).var s = new LineSeries(); s.Title = "Nieciągłe przedziały"; s.Points.Add(new DataPoint(2, 1)); s.Points.Add(new DataPoint(3, 1)); s.Points.Add(new DataPoint(Double.NaN, Double.NaN)); s.Points.Add(new DataPoint(4, 1)); s.Points.Add(new DataPoint(6, 1)); s.Points.Add(new DataPoint(Double.NaN, Double.NaN)); s.Points.Add(new DataPoint(8, 1)); s.Points.Add(new DataPoint(10, 1));Na koniec jeszcze przykład tak skonstruowanego wykresu:
 |  |
orcid.org/0000-0002-6838-2135