CREATE TABLE dbo.Hierarchy ( Parent INT, Child INT ); INSERT INTO dbo.Hierarchy(Parent, Child) VALUES (1,2), (1,3), (1,4), (2,5), (2,6), (4,5), (5,7), (7,8), (6,8);Następnie wyciągniemy z niej dane, bazując na tym, że w formacie GraphViz węzeł rodzic i węzeł dziecko połączone są strzalką ->:
SELECT CAST(Parent AS VARCHAR) + '->' + CAST(Child AS VARCHAR) FROM dbo.HierarchyWynik zapytanie wystarczy skopiować i umieścić na stronie GraphViz Workspace:
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Method)]
public sealed class ExtensionAttribute : Attribute { }
}
Trochę to brzydkie, ale możemy cieszyć się metodami rozszerzającymi w projektach korzystających ze starej wersji platformy. Atrybut ten jest potrzebny, ponieważ kompilator wykorzystuje go do oznaczenia metod tak, aby było wiadomo, które metody z różnych bibliotek są metodami rozszerzającymi.
CREATE TABLE Test ( ID Int IDENTITY(1,1) PRIMARY KEY, Name CHAR(10) ) CREATE INDEX IX_TEST_NAME ON dbo.Test (Name)Teraz na wejściu dostajemy pewien ciąg znaków i przechowujemy go w zmiennej:
DECLARE @Variable CHAR(10); SET @Variable = '1234567890';Chcemy znaleźć wszystkie te rekordy, dla których N pierwszych znaków w kolumnie Name jest takie samo jak N pierwszych znaków w zadanym ciągu. Można to zrobić tak (N=3):
SELECT * FROM dbo.Test WHERE LEFT(Name, 3) = LEFT(@Variable, 3)Albo tak:
SELECT * FROM dbo.Test WHERE Name LIKE LEFT(@Variable, 3)+'%'Oba zapytania dadzą ten sam wynik ale jedno z nich będzie zdecydowanie szybsze (dla dużej ilości danych) niż drugie. Które?
ALTER TABLE dbo.Test ADD NAME2 AS LEFT(Name, 3) CREATE INDEX IX_TEST_NAME2 ON dbo.Test(Name2, Name)W takiej sytuacji pierwsze z pokazanych zapytań (te z operatorem =) również użyje operacji INDEX SEEK.
@inproceedings{komorowski2010configuration,
title={Configuration management of mobile agents based on SNMP},
author={Komorowski, Micha{\l}},
booktitle={Rough Sets and Current Trends in Computing},
pages={456--465},
year={2010},
organization={Springer}
}
Przykład zawiera tylko część z możliwych atrybutów i może być dużo bardziej rozbudowany. Kiedy piszę artykuł nie mam ochoty samemu tworzyć takich wpisów, ale niestety nie zawsze razem z artykułem znajdziemy przygotowany wcześniej wpis dla BibTeX'a. W takim wypadku polecam skorzystać ze strony ACM Digital Library lub Google Scholar.Console.WriteLine((2m).Equals(2)); Console.WriteLine((2).Equals(2M));Pierwsza myśli to 2xTrue ale poprawny wynik to True, False. Dzieje się tak ponieważ istnieje niejawna kowersja z typu int na decimal ale nie na odwrót. Czyli w pierwszym przypadku zostanie użyta metoda Equals(decimal value), a w drugim Equals(object value) A piszę o tym ponieważ to jedna z tych rzeczy, o których bardzo łatwo zapomnieć.
decimal d = 2;
Console.WriteLine("d == 2 = {0}", d == 2);
Console.WriteLine("d == (decimal)2 = {0}", d == (decimal)2);
Console.WriteLine("d.Equals(2) = {0}", d.Equals(2));
Console.WriteLine("d.Equals((decimal)2) = {0}", d.Equals((decimal)2));
Tutaj jeszcze nie ma haczyka i odpowiedź to 4XTrue. Zmieńmy jednak jedną liniję:public override bool Equals(object other)
{
if (!this.HasValue)
{
return (other == null);
}
if (other == null)
{
return false;
}
return this.value.Equals(other);
}
Nic skomplikowanego, jeśli zmienna jest ustawiona to ponownie wywoływana jest metoda Equals w tym przypadku Decimal.Equals Odpowiedzi musimy szukać więc dalej. Wszystkie typy numeryczne mają przeciążoną metodę Equals w następujący sposób:public override bool Equals(object value) public override bool Equals(decimal value)Która z nich zostanie wywołana w tej sytuacji? Nullable<T>.Equals ma parametr typu object, a więc Decimal.Equals(object value) pasuje lepiej niż Decimal.Equals(decimal value). Ta pierwsza działa natomiast w ten sposób, że jeśli przekazany parametr nie jest typu decimal to zawsze zwraca false nie sprawdzając czy przekazany obiekt można bezpiecznie konwertować na decimal. I ot cała tajemnica ;)
public bool Equals(T other)
{
if (!this.HasValue)
return false;
return this.value.Equals(other);
}
Z jakiegoś powodu tego nie zrobiono. Przeoczenie czy celowe działanie? Jestem ciekawy Waszych opinii.sqrt(S) = a0 + 1 / (a1 + 1 / (a2 + 1 / (a3 + 1 / (...))))Nim dłuższa sekwencja tym otrzymamy dokładniejsze przybliżenie. Co bardzo ciekawe, dla każdej liczby niewymiernej sekwencja wartości a0, a1, a2... w pewnym momencie stworzy cykl. Na przykład dla sqrt(2) sekwencja ta ma postać:
[1, 1, 2, 1, 2, ...]Natomiast dla sqrt(53):
[7, 3, 1, 1, 3, 14, 3, 1, 1, 3, 14, ...].Jak wyznaczyć taką sekwencję? Algorytm nie jest bardzo skomplikowany i można go zapisać w kilkunastu liniach kodu. Nie będą go jednak tutaj przytaczał, ponieważ doskonały opis znajduje się już na Wikipedii. Zachęcam do wypróbowania swoich sił i jego zaimplementowania.
public class SrvObject
{
public int Id { get; set; }
public string Code { get; set; }
...
}
...
private Dictionary<int, SrvObject> _cache = new Dictionary<int, SrvObject>();
...
if (_cache.Values.Any(x => x.Code == codeToFind))
{
var obj = _cache.Values.FirstOrDefault(x => x.Code == codeToFind);
...
}
else
{
var obj = ReadObject(codeToFind);
_cache.Add(obj.Id, obj);
...
}
Zacznijmy od tego, że mamy klasę, która modeluje jakąś encję z bazy danych i ta encja posiada zarówno identyfikator (wewnętrzny dla systemu) oraz kod, który można na przykład wyświetlić użytkownikowi.| Liczba N | Liczba unikalnych identyfikatorów | Czas (ms) dla dwóch słowników | Czas (ms) dla jednego słownika |
| 100 | 63 | 3 | 4 |
| 500 | 320 | 2 | 4 |
| 1000 | 639 | 2 | 6 |
| 5000 | 3169 | 2 | 96 |
| 10000 | 6326 | 4 | 370 |
| 50000 | 31579 | 14 | 9190 |
var chopsticks = new JoinBlock<Chopstick, Chopstick>(new GroupingDataflowBlockOptions { MaxNumberOfGroups = 1 });
_left.LinkTo(chopsticks.Target1);
_right.LinkTo(chopsticks.Target2);
_chopsticks = chopsticks.Receive();
Ustawienie właściwości MaxNumberOfGroups jest konieczne, aby blok odczytał tylko dwa komunikaty. Odłożenie pałeczek na stół jest natomiast równoważne z wysłaniem komunikatu (pałeczki) z powrotem do bufora tak, aby oczekujący na nie filozofowie mogli rozpocząć jedzenie._left.SendAsync(_chopsticks.Item1); _right.SendAsync(_chopsticks.Item2);Do tego, aby filozofowie mogli informować świat zewnętrzny o tym, co robią, również użyłem klasy BufferBlock<T>. Za każdym razem kiedy jeden z filozofów kończy/rozpoczyna jedzenie wysyła komunikat ze swoim aktualnym stanem. Ja napisałem prostą aplikację w WinForms, która nasłuchuje na te komunikaty i odpowiednio uaktualnia UI.
private readonly BufferBlock<PhilosopherState> _philosophersState = new BufferBlock<PhilosopherState>(); ... _philosophersState.LinkTo(new ActionBlock<PhilosopherState>(state => UpdateState(state)), new DataflowLinkOptions());Każdy filozof modelowany jest przez instancję klasy Philosopher i działa w swoim własnym wątku. Co jakiś losowy czas decyduje, co robić dalej tj.: kontynuować myślenie/jedzenie czy rozpocząć myślenie/jedzenie. Kiedy zbierzemy to wszystko do kupy, otrzymamy następujący kod.
namespace PhilosopherProblemWithDataFlows
{
public class Philosopher
{
private const int SleepTime = 100;
private readonly int _index;
private readonly BufferBlock<Chopstick> _left;
private readonly BufferBlock<Chopstick> _right;
private readonly BufferBlock<PhilosopherState> _philosophersState;
private bool _goHome;
private Tuple<Chopstick, Chopstick> _chopsticks;
public Philosopher(int index, BufferBlock<Chopstick> left, BufferBlock<Chopstick> right, BufferBlock<PhilosopherState> philosophersState)
{
_index = index;
_left = left;
_right = right;
_philosophersState = philosophersState;
}
public void TakeASeat()
{
var rand = new Random((int)DateTime.Now.Ticks);
while (true)
{
if (_goHome)
{
PutChopsticks();
return;
}
if (rand.Next() % 2 == 0)
Eat();
else
Think();
Thread.Sleep((rand.Next(10) + 1) * SleepTime);
}
}
public void GoHome()
{
_goHome = true;
}
private void Eat()
{
if (_chopsticks == null)
{
var chopsticks =
new JoinBlock<Chopstick, Chopstick >(new GroupingDataflowBlockOptions { MaxNumberOfGroups = 1 });
_left.LinkTo(chopsticks.Target1);
_right.LinkTo(chopsticks.Target2);
_chopsticks = chopsticks.Receive();
chopsticks.Complete();
}
_philosophersState.SendAsync(new PhilosopherState { Index = _index, IsEating = true });
}
private void Think()
{
PutChopsticks();
_philosophersState.SendAsync(new PhilosopherState { Index = _index, IsEating = false});
}
private void PutChopsticks()
{
if (_chopsticks != null)
{
_left.SendAsync(_chopsticks.Item1);
_right.SendAsync(_chopsticks.Item2);
_chopsticks = null;
}
}
}
public class Chopstick
{
}
public class PhilosopherState
{
public int Index { get; set; }
public bool IsEating { get; set; }
}
}
namespace PhilosopherProblemWithDataFlows
{
public partial class Form1 : Form
{
private readonly Color EatingColor = Color.Red;
private readonly Color ThinkingColor = Color.Green;
private readonly List<Label> _stateLabels = new List<Label>();
private readonly List<Philosopher> _philosophers = new List<Philosopher>();
private readonly BufferBlock<PhilosopherState> _philosophersState = new BufferBlock<PhilosopherState>();
public Form1()
{
InitializeComponent();
Closing += (sender, args) =>
{
_philosophersState.Complete();
_philosophers.ForEach(p => p.GoHome());
};
_stateLabels.Add(philosopher1);
_stateLabels.Add(philosopher2);
_stateLabels.Add(philosopher3);
_stateLabels.Add(philosopher4);
_stateLabels.Add(philosopher5);
_stateLabels.ForEach(l => l.BackColor = ThinkingColor);
Start();
}
private void Start()
{
_philosophersState.LinkTo(new ActionBlock<PhilosopherState>(state => UpdateState(state)), new DataflowLinkOptions());
var chopsticks = new[]
{
new BufferBlock<Chopstick>(),
new BufferBlock<Chopstick>(),
new BufferBlock<Chopstick>(),
new BufferBlock<Chopstick>(),
new BufferBlock<Chopstick>()
};
foreach (var ch in chopsticks)
ch.Post(new Chopstick());
for (var i = 0; i < 5; ++i)
_philosophers.Add(new Philosopher(
i,
chopsticks[i],
chopsticks[(i + 1) % 5],
philosophersState));
for (var i = 0; i < 5; ++i)
{
var th = new Thread(_philosophers[i].TakeASeat);
th.Start();
}
}
private void UpdateState(PhilosopherState state)
{
var label = _stateLabels[state.Index];
label.Invoke((MethodInvoker)delegate { label.BackColor = state.IsEating ? EatingColor : ThinkingColor; });
}
}
}
var start = DateTime.Now; //... var end = DateTime.Now;Średnie
public void Fun()
{
//Here, I want to get a name of a method that executed/called Fun method
}
Trudne
public class ShipsProblemData
{
public Dictionary<string, Stack<string>> Ports { get; private set; }
public Stack<string> CurrentPath { get; private set; }
public ShipsProblemData()
{
Ports = new Dictionary<string, Stack<string>>();
CurrentPath = new Stack<string>();
}
public ShipsProblemData Clone()
{
var state = new ShipsProblemData();
foreach (var pair in Ports)
{
var stack = new Stack<string>();
foreach (var target in pair.Value.Reverse())
stack.Push(target);
state.Ports[pair.Key] = stack;
}
foreach (var item in CurrentPath.Reverse())
state.CurrentPath.Push(item);
return state;
}
}
public class ShipsProblem : Problem<ShipsProblemData>
{
public override ShipsProblemData DataForInitialState
{
get
{
var data = new ShipsProblemData();
var port1 = "Gdańsk";
var port2 = "Szczecin";
var port3 = "Kołobrzeg";
data.CurrentPath.Push(port1);
var book = new Stack<string>();
book.Push(port2);
book.Push(port1);
book.Push(port3);
book.Push(port2);
book.Push(port1);
book.Push(port3);
data.Ports[port1] = book;
book = new Stack<string>();
book.Push(port3);
book.Push(port1);
book.Push(port1);
book.Push(port3);
book.Push(port1);
book.Push(port1);
data.Ports[port2] = book;
book = new Stack<string>();
book.Push(port2);
book.Push(port3);
book.Push(port2);
book.Push(port2);
book.Push(port3);
book.Push(port2);
data.Ports[port3] = book;
return data;
}
}
public override bool IsFinalState(State<ShipsProblemData> state)
{
return state.Data.Hosts.All(kvp => !kvp.Value.Any());
}
public override IList<State<ShipsProblemData>> Expand(State<MyData> state)
{
var newStates = new List<State<ShipsProblemData>>);
var currentHost = state.Data.CurrentPath.Peek();
foreach (var host in state.Data.Hosts.Keys)
{
if (state.Data.Hosts[host].Count > 0 && state.Data.Hosts[host].Peek() == currentHost)
{
var copy = state.Data.Clone();
copy.Hosts[host].Pop();
copy.CurrentPath.Push(host);
newStates.Add(new State<ShipsProblemData> { Data = copy });
}
}
return newStates;
}
}
var solver = new ProblemSolver<ShipsProblemData>();
var results = solver.SolveProblem(new DFSFringe<ShipsProblemData>(), new ShipsProblem ());
foreach (var res in results)
{
Console.WriteLine(" ----------- Solution ----------- ");
foreach (var data in res.ResultData)
Console.WriteLine(data.CurrentPath.Peek());
}
public class DFSFringe<TCustomData> : Fringe<TCustomData>
{
private readonly Stack<State<TCustomData>> _fringe = new Stack<State<TCustomData>>();
public override int Count
{
get { return _fringe.Count; }
}
public override bool IsEmpty
{
get { return _fringe.Count == 0; }
}
public override State<TCustomData> Next
{
get { return _fringe.Pop(); }
}
public override void Add(State<TCustomData> s)
{
_fringe.Push(s);
}
}
public class BFSFringe<TCustomData> : Fringe<TCustomData>
{
private readonly Queue<State<TCustomData>> _fringe = new Queue<State<TCustomData>>();
public override int Count
{
get { return _fringe.Count; }
}
public override bool IsEmpty
{
get { return _fringe.Count == 0; }
}
public override State<TCustomData> Next
{
get { return _fringe.Dequeue(); }
}
public override void Add(State<TCustomData> s)
{
_fringe.Enqueue(s);
}
}
public class State<TCustomData>
{
public TCustomData Data { get; set; }
public double Cost { get; set; }
public State<TCustomData> Parent { get; internal set; }
public IList<State<TCustomData>> Children { get; internal set; }
}
public abstract class Problem<TCustomData>
{
public abstract TCustomData DataForInitialState { get; }
public abstract bool IsFinalState(State<TCustomData> state);
public abstract IList<State<TCustomData>> Expand(State<TCustomData> state);
}
public abstract class Fringe<TCustomData>
{
public abstract State<TCustomData> Next { get; }
public abstract int Count { get; }
public abstract bool IsEmpty { get; }
public abstract void Add(State<TCustomData> s);
public void AddRange(IEnumerable<State<TCustomData>> data)
{
foreach (var s in data)
Add(s);
}
}
public class Result<TCustomData>
{
private readonly List<TCustomData> _resultData = new List<TCustomData>();
public IList<TCustomData> ResultData
{
get { return _resultData; }
}
}
public class ProblemSolver<TCustomData>
{
public IList<Result<TCustomData>> SolveProblem(Fringe<TCustomData> fringe, Problem<TCustomData> problem)
{
var initialState = new State<TCustomData> { Data = problem.DataForInitialState };
fringe.Add(initialState);
var res = new List<Result<TCustomData>>();
while (!fringe.IsEmpty)
{
var next = fringe.Next;
if (problem.IsFinalState(next))
{
res.Add(GetSolution(next));
}
else
{
next.Children = problem.Expand(next);
foreach (var child in next.Children)
child.Parent = next;
fringe.AddRange(next.Children);
}
}
return res;
}
private static Result<TCustomData> GetSolution(State<TCustomData> state)
{
var res = new Result<TCustomData>();
while (state != null)
{
res.ResultData.Add(state.Data);
state = state.Parent;
}
return res;
}
}
| Szczecin | Gdańsk | Kołobrzeg |
| Gdańsk | Kołobrzeg | Gdańsk |
| Kołobrzeg | Kołobrzeg | Szczecin |
| Szczecin | Gdańsk |
| Gdańsk | Szczecin | Kołobrzeg |
| Szczecin | Kołobrzeg | Szczecin |
| Gdańsk | Gdańsk | Kołobrzeg |
| Kołobrzeg | Gdańsk | Szczecin |
| Szczecin | Kołobrzeg | Szczecin |
| Gdańsk | Gdańsk | Kołobrzeg |
| Kołobrzeg | Gdańsk | Szczecin |
public override void Up()
{
AddColumn("TranslationEntities", "Translation2", c => c.String(true, maxLength: 4000, storeType: "nvarchar"));
}
Database.SetInitializer(new MigrateDatabaseToLatestVersion<ExpressionsDataContext, Configuration>());
orcid.org/0000-0002-6838-2135