184 lines
4.9 KiB
Markdown
184 lines
4.9 KiB
Markdown
# Either
|
|
|
|
### Jak używać
|
|
|
|
Either umożliwa nam zwrócenie z metody bądź nawet kontrolera, dwóch możliwych wyników.
|
|
Dla ułatwienia zrozumienai poniżej podaję przykłady stosowania.
|
|
|
|
Jako typ zmiennej zwracanej z api:
|
|
W tym przypadku wskazujemy, że nasze api zwróci albo CharacterViewModel albo ErrorResponse
|
|
```cs
|
|
public async Task<Either<CharacterViewModel, ErrorResponse>> Get(int id)
|
|
```
|
|
Aby zwrócić ten typ mamy dwie możliwości.
|
|
Możemy wywołać metodę z serisu, która ma nam zwrócić CharacterViewModel.
|
|
Następnie sprawdzić czy otrzymana wartość CharacerViewModel zawiera jakiekolwiek dane i odpowiednio, jeśli tak to zwracamy otrzymany viewmodel a jeśli nie tworzymy ErrorResponse i zwracamy wynik:
|
|
```cs
|
|
public async Task<Either<CharacterViewModel, ErrorResponse>> Get(int id)
|
|
{
|
|
Either<CharacterViewModel, ErrorResponse> result = await _service.Get(id);
|
|
|
|
if (result.Left != null)
|
|
{
|
|
return result;
|
|
}
|
|
else
|
|
{
|
|
result = new ErrorResponse { StatusCode = 400, Message = "Coś poszło nie tak" };
|
|
|
|
return result;
|
|
}
|
|
}
|
|
```
|
|
W przypadku jesli serwis nie znajdzie wartości otrzymamy:
|
|
```json
|
|
{
|
|
"left":null,
|
|
"right":{
|
|
"statusCode":400,
|
|
"message":"Coś poszło nie tak"},
|
|
"isLeft":false}
|
|
```
|
|
|
|
Drugim sposobem jest zmiana działania serwisu:
|
|
|
|
```cs
|
|
public async Task<Either<CharacterViewModel, ErrorResponse>> GetCharacter(int id)
|
|
{
|
|
var repoResult = await this.Repository.Get(id);
|
|
if (repoResult != null)
|
|
{
|
|
return Mapper.Map<CharacterViewModel>(repoResult);
|
|
}
|
|
else
|
|
{
|
|
return new ErrorResponse()
|
|
{
|
|
StatusCode = 404,
|
|
Message = "Coś poszło nie tak"
|
|
};
|
|
}
|
|
}
|
|
```
|
|
|
|
Wtedy kontroler wygląda tak :
|
|
```sh
|
|
public async Task<Either<CharacterViewModel, ErrorResponse>> Get(int id)
|
|
{
|
|
return await this._service.GetCharacter(id);
|
|
}
|
|
```
|
|
|
|
### Przypisanie nowej wartości
|
|
Jeśli z jakiegośpowodu będziemy chcieli zmienić wartość obiektu Either, musimy dokonać tego w taki oto sposób:
|
|
```cs
|
|
UserViewModel user = new UserViewModel() { Id = 1, Username = "Testowy", Password = "Secret" };
|
|
Either<UserViewModel, string> test = "asd";
|
|
|
|
// zmieniamy wartość Either
|
|
test = user;
|
|
|
|
// Warto zauważyć, że możemy zmienić wartość obiektu znajdujacego się wewnątrz
|
|
// którejś ze zmiennej o ile jest on publiczny
|
|
test.Left.Username = "test";
|
|
|
|
// Jednak jeśli dokonamy tego po zmianie wartości obietu na inny pomimo tego, że
|
|
// dla kodu jest to ok, to nie zadziała to poprawnie, ponieważ wartość starego obiektu
|
|
// jest zmieniana na null(dla boola na false)
|
|
test = "asd";
|
|
test.Left.Username = "błąd";
|
|
|
|
```
|
|
|
|
### LeftOrDefault() oraz RightOrDefault()
|
|
|
|
Zwracają one wartość wybranej zmiennej bądź jej wartość defaultową.
|
|
Dla wiekszości obiektów jest to null, wyjatkiem jest tutaj bool, który zwróci nam false.
|
|
```cs
|
|
var test = (Either<bool, string>)true;
|
|
|
|
var a = test.LeftOrDefault(); // zwróci nam true
|
|
var b = test.RightOrDefault(); // zwróci nam null
|
|
|
|
test = "asd";
|
|
|
|
var c = test.LeftOrDefault(); // zwróci nam false
|
|
var d = test.RightOrDefault(); // zwróci nam "asd"
|
|
```
|
|
|
|
### Match
|
|
|
|
Funkcja ta pozwala nam na odpalenie odpowiedniej metody w zależności od tego jako typ zmiennej jest aktualnie przechowywany w obiekcie Either. Niestety ograniczeniem jest to, ze obie funkcje musza docelowo zwrócić ten sam typ.
|
|
```cs
|
|
// ładujemy userviewmodel do obiektu Either i wywoływamy matcha pdając dwie funkcje
|
|
test = user;
|
|
// zwwrócny zostanie string "Test1"
|
|
test.Match(this.Test1, this.Test2);
|
|
|
|
// ładujemy stringa do obiektu Either i wywoływamy matcha pdając dwie funkcje
|
|
test = "asd";
|
|
// zwwrócny zostanie string "Test2"
|
|
test.Match(this.Test1, this.Test2);
|
|
|
|
public string Test1(UserViewModel viewModel)
|
|
{
|
|
return "Test1";
|
|
}
|
|
|
|
public string Test2(string text)
|
|
{
|
|
return "Test2";
|
|
}
|
|
```
|
|
|
|
Warto zauważyć, że możemy wykorzystać tutaj lambde by rozszerzyć nasze możliwości:
|
|
```cs
|
|
test = "asd";
|
|
|
|
test.Match(
|
|
Test1,
|
|
second =>
|
|
{
|
|
int z = Test2(second);
|
|
// tutaj możemy robić już co nam się tylko podoba
|
|
// pamiętać należy ze finalnie musimy coś zwrócić
|
|
// chyba, że nasze obie funkcje są typu void
|
|
return z.ToString();
|
|
});
|
|
|
|
public string Test1(UserViewModel viewModel)
|
|
{
|
|
return "Test1";
|
|
}
|
|
|
|
public int Test2(string text)
|
|
{
|
|
return 12;
|
|
}
|
|
```
|
|
|
|
Możemy też podać jedna funkcję typu void a drugą typu innego np. string albo int:
|
|
```cs
|
|
y = "";
|
|
test = "asd";
|
|
|
|
test.Match(
|
|
Test1,
|
|
second =>
|
|
{
|
|
var x = this.Test2(second);
|
|
//jednak nie ma możliwości zwrócenia wartości
|
|
// możemy za to zwrócić wyniki do zewnętrznej zmiennej
|
|
y = x;
|
|
});
|
|
|
|
public void Test1(UserViewModel viewModel)
|
|
{
|
|
//...coś robi
|
|
}
|
|
|
|
public string Test2(string text)
|
|
{
|
|
return "Test2";
|
|
}
|
|
``` |