آموزش برنامه نویسی غیر همزمان در Flutter

void main() async {
  /// Create a Future from the default constructor
  await Future(() async {
    /// Use the delayed constructor to create a Future that will resolve after x time.
    await Future<void>.delayed(Duration(seconds: 2));
    
    print("hello");
  });
  
  /// Do not freeze the code
  doARequest();
  
  /// Freeze the code
  await doARequest();
  
  /// It will not freeze the code because the function does not return an object of type Future
  await doARequest2();
  
  
  /// Freeze the code until the future is completed
  final String t = await retrieveStringFromStorage();
  final String t2 = await retrieveStringFromStorage2();
  
  /// Will print true !
  print(t == t2);
}

Future<void> doARequest() async {
  await requestToServer();
}

void doARequest2() async {
  await requestToServer();
}

Future<String> retrieveStringFromStorage() async {
  final String t = await getStringFromStorage();

  return t;
}

/// Is equivalent to
Future<String> retrieveStringFromStorage2() => getStringFromStorage();

 import 'dart:async';

void main() {
  StreamLife streamLife = StreamLife();
}

class StreamLife {
  StreamLife() {
    controller2.add('eventBeforeListener');

    subscription1 = stream.listen((String value) {
      print(value + ' - sub1');
    });

    subscription2 = stream.listen((String value) {
      print(value + ' - sub2');
    });
    
    subscription3 = stream2.listen((String value) {
      print(value + ' - sub3');
    });
    
    launch();
  }

  final StreamController<String> controller = StreamController<String>.broadcast();
  final StreamController<String> controller2 = StreamController<String>();

  Stream<String> get stream => controller.stream;
  Stream<String> get stream2 => controller2.stream;
  
  StreamSubscription subscription1;
  StreamSubscription subscription2;
  StreamSubscription subscription3;
  
  Future<void> launch() async {
    await Future<void>.delayed(Duration(milliseconds: 100));
    
    controller.add('one');
   
    await Future<void>.delayed(Duration(milliseconds: 100));
    
    controller.add('two');
    
    await Future<void>.delayed(Duration(milliseconds: 100));
    
    subscription1.cancel();
    
    await Future<void>.delayed(Duration(milliseconds: 100));
    
    controller.add('tree');
    
    await Future<void>.delayed(Duration(milliseconds: 100));
    
    subscription2.cancel();

    await Future<void>.delayed(Duration(milliseconds: 100));
    
    controller2.add('ttt');

    await Future<void>.delayed(Duration(milliseconds: 100));
    
    try {
      stream2.listen((String v) {
        print(v);
      });
    }
    catch (e) {
      /// this will not work because there is already a listener on the stream2! (single subscription)
    }

    await Future<void>.delayed(Duration(milliseconds: 100));
    
    subscription3.cancel();
  }
}

 eventBeforeListtener — sub3
one — sub1 
one — sub2 
two — sub1 
two — sub2 
tree — sub2 
ttt — sub3